diff --git a/packages/amico-run/src/jev_calibration.ts b/packages/amico-run/src/jev_calibration.ts
new file mode 100644
index 00000000..d59dd263
--- /dev/null
+++ b/packages/amico-run/src/jev_calibration.ts
@@ -0,0 +1,125 @@
+// jev_calibration.ts — issue #1311 (slice of #1301 session curation): the
+// calibration BATTERY graders — the curation spec's discipline ("thresholds
+// are evaluated on our data, never cookbook"; Brier + reliability per
+// primitive, re-run on model-version changes). The hand-labeled set is the
+// 2026-09-20 sweep (test/fixtures/jev/calibration-2026-09-20.json — six
+// sessions, two junk / one borderline / three substantive, provenance in the
+// curation spec §Calibration).
+//
+// PURE graders over (entries, answers) — the unit suite grades the RECORDED
+// 2026-09-20 answers (reproducing the sweep numbers: 5/6 bucket agreement,
+// noul spread 0.05→0.91); the LIVE battery (test/slow/jev_calibration.test.ts
+// — network, opt-in env, never in the unit suite) replays the same set
+// through the real client on demand and grades whatever the model answers
+// TODAY, so a version change can be re-qualified mechanically.
+import { JUNK_BUCKETS, jevJunkResidual, jevThreadNouls, type CurationDeps, type SessionFeaturesLite } from "./jev_curation.js";
+
+/** One hand-labeled calibration session. */
+export interface CalibrationEntry {
+  session_id: string;
+  features: SessionFeaturesLite;
+  last_text: string;
+  hand_bucket: string;
+  hand_has_thread: boolean;
+  recorded?: { choice?: string; confidence?: number; noul?: number };
+}
+
+/** The choice answer shape the graders consume (client answer or recorded). */
+export interface ChoiceAnswer {
+  choice?: string;
+  confidence?: number;
+  probabilities?: Record<string, number>;
+}
+
+const actionOf = (bucket: string): "archive" | "keep" => ((JUNK_BUCKETS as readonly string[]).includes(bucket) ? "archive" : "keep");
+
+/** Grade the Choice battery: bucket agreement, ACTION agreement (the honest
+ * axis — the sweep's single mismatch was action-irrelevant: both buckets
+ * archive), and multiclass Brier over the closed option set when every
+ * judged answer carries probabilities. Judged = sessions with an answer;
+ * a session the client missed is never guessed. */
+export function gradeChoiceBattery(entries: CalibrationEntry[], answers: Record<string, ChoiceAnswer>) {
+  const judged = entries.filter((e) => answers[e.session_id]?.choice !== undefined);
+  const mismatches = judged
+    .filter((e) => answers[e.session_id].choice !== e.hand_bucket)
+    .map((e) => {
+      const jev = answers[e.session_id].choice as string;
+      const sameAction = actionOf(jev) === actionOf(e.hand_bucket);
+      return {
+        session_id: e.session_id,
+        hand: e.hand_bucket,
+        jev,
+        ...(sameAction ? { note: "action-irrelevant: both buckets archive" } : {}),
+      };
+    });
+  const allProbabilities = judged.every((e) => answers[e.session_id].probabilities !== undefined);
+  let brier: number | null = null;
+  if (judged.length > 0 && allProbabilities) {
+    const options = new Set<string>(judged.flatMap((e) => Object.keys(answers[e.session_id].probabilities ?? {})));
+    for (const e of judged) {
+      options.add(e.hand_bucket);
+      options.add(answers[e.session_id].choice as string);
+    }
+    brier =
+      judged.reduce((sum, e) => {
+        const probs = answers[e.session_id].probabilities ?? {};
+        return sum + [...options].reduce((s, o) => s + ((probs[o] ?? 0) - (e.hand_bucket === o ? 1 : 0)) ** 2, 0);
+      }, 0) / judged.length;
+  }
+  return {
+    judged: judged.length,
+    agree: judged.length - mismatches.length,
+    action_agree: judged.filter((e) => actionOf(answers[e.session_id].choice as string) === actionOf(e.hand_bucket)).length,
+    mismatches,
+    brier,
+    ...(brier === null && judged.length > 0 ? { brier_reason: "choice Brier needs full probabilities per judged answer" } : {}),
+  };
+}
+
+/** Grade the Noul battery: spread (min/max over judged) + Brier
+ * ((noul − y)², y = hand_has_thread). Judged = sessions with a noul. */
+export function gradeNoulBattery(entries: CalibrationEntry[], nouls: Record<string, number>) {
+  const judged = entries.filter((e) => nouls[e.session_id] !== undefined);
+  const values = judged.map((e) => nouls[e.session_id]);
+  return {
+    judged: judged.length,
+    spread: { min: Math.min(...values), max: Math.max(...values) },
+    brier:
+      judged.length === 0
+        ? null
+        : judged.reduce((sum, e) => sum + (nouls[e.session_id] - (e.hand_has_thread ? 1 : 0)) ** 2, 0) / judged.length,
+  };
+}
+
+/** The full battery pass: replay every entry through BOTH loops (one choice +
+ * one noul per session — exactly the production call sites' questions) and
+ * grade. Hermetic under a stubbed transport; live under the real one. */
+export async function runCalibrationBattery(
+  entries: CalibrationEntry[],
+  deps: CurationDeps = {},
+  now: () => number = Date.now,
+): Promise<{
+  ts: string;
+  status: "ran" | "unavailable" | "disabled";
+  choice: ReturnType<typeof gradeChoiceBattery>;
+  noul: ReturnType<typeof gradeNoulBattery>;
+}> {
+  const residual = await jevJunkResidual(
+    entries.map((e) => ({ id: e.session_id, features: e.features, ageHours: 72 })),
+    deps,
+  );
+  const nouls = await jevThreadNouls(
+    entries.map((e) => ({ id: e.session_id, title: e.features.title, lastAssistantText: e.last_text, pendingTodos: e.features.todo_count })),
+    deps,
+  );
+  const answers: Record<string, ChoiceAnswer> = {};
+  for (const [id, verdict] of Object.entries(residual.verdicts)) {
+    if (verdict.choice !== undefined) answers[id] = { choice: verdict.choice, confidence: verdict.confidence, probabilities: verdict.probabilities };
+  }
+  return {
+    ts: new Date(now()).toISOString(),
+    status: residual.status,
+    choice: gradeChoiceBattery(entries, answers),
+    noul: gradeNoulBattery(entries, nouls.nouls),
+  };
+}
diff --git a/packages/amico-run/src/jev_client.ts b/packages/amico-run/src/jev_client.ts
new file mode 100644
index 00000000..81dea361
--- /dev/null
+++ b/packages/amico-run/src/jev_client.ts
@@ -0,0 +1,221 @@
+// jev_client.ts — issue #1311 (slice of #1301 session curation): the ONE thin
+// Jev client — TypeSafe AI's System One decision model — for amicode's
+// confidence-gated curation middle layer.
+//
+// DOCTRINE (spec-20260920-jev-integration): deterministic rules are the front
+// line; Jev is the middle layer on the residual only; every call is logged as
+// ONE JSON decision record in the curation receipts journal (the S2 archiver's
+// shared JSONL); fail-open everywhere — Jev down/slow/low-confidence degrades
+// to today's behavior, never blocks a caller.
+//
+// WIRE CONTRACT (live-verified 2026-09-20 against the vendor API — the shape
+// is the contract of record, superseding any earlier drafts):
+//   POST https://api.typesafe.ai/v1/systemone
+//   Authorization: Bearer <key>   (Content-Type: application/json)
+//   {"model":"jev-latest","state":<string|object>,"questions":{"<id>":<Question>}}
+//   Question = {"type":"choice"|"noul","instructions":<string>,
+//               "criteria":<choice: MAP option→rubric | noul: {"true":…,"false":…}>}
+//   Response = {"model":"jev-1.13.0","answers":{"<id>":…},"usage":{"input_tokens":N,"output_tokens":N}}
+//   choice answer = {"type":"choice","choice":"<option>","confidence":<float>,"probabilities":{…}}
+//   noul answer   = {"type":"noul","noul":<float>}
+// (~330–370 ms/call, ~500 input tokens — the microdollar band; state stays a
+// deterministic fold, never a raw spine.)
+//
+// SECURITY POSTURE: the vendor key is server-side at ~/.amico/typesafe/key
+// (mode 600), read at CALL time — never committed, never in a receipt, never
+// in an error string. A missing/unreadable key = UNAVAILABLE: callers take
+// the fail-open path. $AMICO_TYPESAFE_KEY_FILE overrides the path (tests).
+//
+// OFF-SWITCH: $AMICO_JEV_DISABLED truthy disables the entire Jev path with
+// zero behavioral delta (the S2 ops-job env-flag convention).
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/** The decision endpoint — live-verified; no OpenRouter listing for our key. */
+export const JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+
+/** The model alias — the concrete version (e.g. jev-1.13.0) rides the response
+ * and every receipt, so thresholds can be re-qualified on version changes. */
+export const JEV_MODEL = "jev-latest";
+
+/** One question over the confirmed shapes. `criteria` is a choice's
+ * option→rubric MAP (a "no-match" option is one of OUR options) or a noul's
+ * true/false description pair. */
+export interface JevQuestion {
+  type: "choice" | "noul";
+  instructions: string;
+  criteria: Record<string, string>;
+}
+
+/** A choice answer (typed verdict + calibrated confidence) or a noul
+ * probability-of-yes. */
+export type JevAnswer =
+  | { type: "choice"; choice: string; confidence: number; probabilities?: Record<string, number> }
+  | { type: "noul"; noul: number };
+
+export type JevUsage = { input_tokens: number; output_tokens: number };
+
+/** The transport seam — injectable so the suite runs hermetically (no
+ * network); the default is fetch with a bounded timeout (fail-open on slow). */
+export type JevTransport = (
+  url: string,
+  init: { method: string; headers: Record<string, string>; body: string; signal?: AbortSignal },
+) => Promise<{ status: number; text(): Promise<string> }>;
+
+/** A slow Jev is a failed Jev: the latency budget is per-session seams
+ * (~350 ms expected); nothing waits on this client. */
+export const JEV_TIMEOUT_MS = 10_000;
+
+/** $AMICO_TYPESAFE_KEY_FILE → ~/.amico/typesafe/key (the secrets posture). */
+export function jevKeyFile(env: NodeJS.ProcessEnv = process.env): string {
+  const v = env.AMICO_TYPESAFE_KEY_FILE;
+  return v && v.trim() !== "" ? v : join(homedir(), ".amico", "typesafe", "key");
+}
+
+/** Truthy off-switch values; "0"/"false"/"no"/"off" keep the path enabled. */
+export function jevDisabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const v = (env.AMICO_JEV_DISABLED ?? "").trim().toLowerCase();
+  return v !== "" && !["0", "false", "no", "off"].includes(v);
+}
+
+/** The shared receipts journal (the S2 archiver's upgrade-receipts JSONL —
+ * $AMICO_TYPESAFE_RECEIPTS → $AMICO_SERVER_DIR/upgrade-receipts/… → the default). */
+export function jevReceiptsFile(env: NodeJS.ProcessEnv = process.env): string {
+  const override = env.AMICO_TYPESAFE_RECEIPTS;
+  if (override && override.trim() !== "") return override;
+  const server = env.AMICO_SERVER_DIR && env.AMICO_SERVER_DIR.trim() !== "" ? env.AMICO_SERVER_DIR : join(homedir(), ".amico", "server");
+  return join(server, "upgrade-receipts", "upgrade-receipts.jsonl");
+}
+
+export interface JevDeps {
+  env?: NodeJS.ProcessEnv;
+  transport?: JevTransport;
+  /** Receipts journal path; default jevReceiptsFile(env). */
+  receiptsPath?: string;
+  now?: () => number;
+}
+
+export type JevResult =
+  | {
+      ok: true;
+      model: string;
+      answers: Record<string, JevAnswer>;
+      usage: JevUsage;
+      latency_ms: number;
+      /** Where the decision record landed (audit); undefined only if the
+       * receipt write itself failed — the call still returns its answers. */
+      receipt_path?: string;
+    }
+  | { ok: false; reason: "disabled" | "key-missing" | "http" | "malformed" | "transport"; error: string };
+
+/** One Jev decision call: one or more questions over one state fold. NEVER
+ * throws — every failure is {ok:false} and the caller's fail-open path.
+ * Receipts: exactly ONE JSON decision-record line per attempted call (success
+ * or failure) in the curation receipts journal; no call, no receipt. */
+export async function askJev(
+  questions: Record<string, JevQuestion>,
+  state: unknown,
+  opts: { sessionId?: string; deps?: JevDeps } = {},
+): Promise<JevResult> {
+  const deps = opts.deps ?? {};
+  const env = deps.env ?? process.env;
+  if (jevDisabled(env)) return { ok: false, reason: "disabled", error: "jev path disabled (AMICO_JEV_DISABLED)" };
+
+  const keyPath = jevKeyFile(env);
+  if (!existsSync(keyPath)) return { ok: false, reason: "key-missing", error: `jev key not found at ${keyPath} — the middle layer is unavailable; fail-open` };
+  let key: string;
+  try {
+    key = readFileSync(keyPath, "utf8").trim();
+  } catch {
+    return { ok: false, reason: "key-missing", error: `jev key unreadable at ${keyPath} — the middle layer is unavailable; fail-open` };
+  }
+  if (key === "") return { ok: false, reason: "key-missing", error: `jev key empty at ${keyPath} — the middle layer is unavailable; fail-open` };
+
+  const stateJson = JSON.stringify(state);
+  const body = JSON.stringify({ model: JEV_MODEL, state, questions });
+  const started = (deps.now ?? Date.now)();
+
+  const receiptOf = (result: JevResult): void => {
+    // The decision record — one JSON line per call, the S2 receipts pattern.
+    // A failed receipt write never fails the call (fail-open, both ways).
+    const receipts = deps.receiptsPath ?? jevReceiptsFile(env);
+    const answered = result.ok ? Object.values(result.answers) : [];
+    const verdicts = Object.entries(result.ok ? result.answers : {}).map(([id, a]) => ({
+      id,
+      ...(a.type === "choice" ? { choice: a.choice, confidence: a.confidence } : { noul: a.noul }),
+    }));
+    const line = JSON.stringify({
+      receipt_version: 1,
+      ts: new Date(started).toISOString(),
+      kind: "jev-decision",
+      session_id: opts.sessionId,
+      primitive: Object.values(questions).map((q) => q.type).join("+"),
+      state_bytes: Buffer.byteLength(stateJson, "utf8"),
+      ...(verdicts.length > 0 ? { verdicts } : {}),
+      ...(answered.length > 0 && answered[0].type === "choice" ? { confidence: answered[0].confidence } : {}),
+      latency_ms: (deps.now ?? Date.now)() - started,
+      model: result.ok ? result.model : null,
+      ...(result.ok ? { usage: result.usage } : {}),
+      ...(!result.ok ? { error: result.error } : {}),
+    });
+    try {
+      mkdirSync(dirname(receipts), { recursive: true });
+      appendFileSync(receipts, `${line}\n`);
+      if (result.ok) result.receipt_path = receipts;
+    } catch {
+      // the audit trail is best-effort; the decision still returns
+    }
+  };
+
+  let res: { status: number; text(): Promise<string> };
+  try {
+    const transport = deps.transport ?? defaultTransport();
+    res = await transport(JEV_ENDPOINT, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+      body,
+      signal: AbortSignal.timeout(JEV_TIMEOUT_MS),
+    });
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    const result: JevResult = { ok: false, reason: "transport", error: error.slice(0, 160) };
+    receiptOf(result);
+    return result;
+  }
+  if (res.status !== 200) {
+    const result: JevResult = { ok: false, reason: "http", error: `jev endpoint answered HTTP ${res.status}` };
+    receiptOf(result);
+    return result;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await res.text());
+  } catch {
+    const result: JevResult = { ok: false, reason: "malformed", error: "jev endpoint returned a malformed body" };
+    receiptOf(result);
+    return result;
+  }
+  const o = (typeof parsed === "object" && parsed !== null ? parsed : {}) as Record<string, unknown>;
+  const answers = (typeof o.answers === "object" && o.answers !== null ? o.answers : {}) as Record<string, JevAnswer>;
+  if (typeof o.model !== "string" || o.model === "" || Object.keys(answers).length === 0) {
+    const result: JevResult = { ok: false, reason: "malformed", error: "jev endpoint returned no model or no answers" };
+    receiptOf(result);
+    return result;
+  }
+  const usage = (typeof o.usage === "object" && o.usage !== null ? o.usage : { input_tokens: 0, output_tokens: 0 }) as JevUsage;
+  const result: JevResult = { ok: true, model: o.model, answers, usage, latency_ms: (deps.now ?? Date.now)() - started };
+  receiptOf(result);
+  return result;
+}
+
+/** The production transport: global fetch (Node 20+). */
+function defaultTransport(): JevTransport {
+  return (url, init) =>
+    fetch(url, {
+      method: init.method,
+      headers: init.headers,
+      body: init.body,
+      signal: init.signal,
+    }) as unknown as Promise<{ status: number; text(): Promise<string> }>;
+}
diff --git a/packages/amico-run/src/jev_curation.ts b/packages/amico-run/src/jev_curation.ts
new file mode 100644
index 00000000..ac8aad72
--- /dev/null
+++ b/packages/amico-run/src/jev_curation.ts
@@ -0,0 +1,184 @@
+// jev_curation.ts — issue #1311 (slice of #1301 session curation): the two
+// confidence-gated call sites over the ONE thin Jev client (jev_client.ts):
+//
+//   (a) classifier residual — sessions the deterministic #1303 rules leave
+//       unclassified get ONE Jev Choice over the closed junk-bucket set (with
+//       an "unclassified" no-match option). Archive admission ONLY at
+//       junk-bucket p ≥ 0.95 AND age ≥ 48 h — the curation spec's calibrated
+//       pair ("never act on an ambiguous mid-confidence read"); everything
+//       else — below threshold, no-match, any client failure — leaves the
+//       session as-is (fail-open).
+//
+//   (b) onset thread-Noul — ONE Noul per digest candidate ("does this session
+//       have an open thread?"). The ≥ 0.5 promotion + ranking live in the
+//       onset digest module (the plugin); THIS module only produces the map.
+//       Jev never derives a bucket label anywhere.
+//
+// PURITY: the gates and question builders are pure functions of their
+// arguments (the #1303 classifier discipline); the loops take injectable
+// deps (transport, receipts, clock, env) so the suite runs hermetically —
+// no test touches network or the real key.
+import { askJev, type JevAnswer, type JevDeps, type JevQuestion } from "./jev_client.js";
+
+/** The deps both loops take — injectable for hermetic tests (jev_client's JevDeps). */
+export type CurationDeps = JevDeps;
+
+/** Archive admission floor — the curation spec's calibrated Choice gate. */
+export const JEV_ARCHIVE_CONFIDENCE_MIN = 0.95;
+
+/** The Jev residual's FIXED age gate — independent of (never narrower than)
+ * the archiver's scan cutoff: a tab opened 5 minutes ago must never vanish
+ * on a model's word even if the scan runs --hours 1. */
+export const JEV_ARCHIVE_MIN_AGE_HOURS = 48;
+
+/** The buckets that archive (the #1303 closed set's junk half). */
+export const JUNK_BUCKETS = ["junk-greeting", "dead-cast", "probe"] as const;
+
+/** The classifier-residual choice: ONE question over the closed bucket set,
+ * the no-match option being one of OUR options ("unclassified"). */
+export const JUNK_BUCKET_RUBRIC: Record<string, string> = {
+  "junk-greeting": "a greeting/test/smoke-titled session with minimal user text and at most a few assistant turns",
+  "dead-cast": "a spawned session that never got a single assistant reply (at most one user message)",
+  probe: "a session that was opened but never used — no user and no assistant messages",
+  substantive: "a session carrying real work — substantive user text, many assistant turns, or pending todos",
+  unclassified: "none of the above fits this session",
+};
+
+/** The deterministic fold the classifier residual feeds Jev — counts and the
+ * title, never message text (the state-budget doctrine: digests, not spines). */
+export interface SessionFeaturesLite {
+  title: string;
+  user_message_count: number;
+  user_text_chars: number;
+  assistant_message_count: number;
+  todo_count: number;
+}
+
+/** The residual question: state fold + choice question over the closed set. */
+export function junkResidualQuestion(f: SessionFeaturesLite): { question: JevQuestion; state: SessionFeaturesLite } {
+  return {
+    question: {
+      type: "choice",
+      instructions: "Classify this chat session into exactly one bucket. The session is NOT in any deterministic junk bucket — judge which bucket it truly belongs to.",
+      criteria: JUNK_BUCKET_RUBRIC,
+    },
+    state: {
+      title: f.title,
+      user_message_count: f.user_message_count,
+      user_text_chars: f.user_text_chars,
+      assistant_message_count: f.assistant_message_count,
+      todo_count: f.todo_count,
+    },
+  };
+}
+
+/** The calibrated admission gate (pure): a junk-bucket Choice at p ≥ 0.95
+ * AND age ≥ 48 h — nothing else admits. `choice` undefined (call failed,
+ * no answer) admits nothing: the fail-open path. */
+export function jevArchiveAdmits(choice: string | undefined, confidence: number, ageHours: number): boolean {
+  if (choice === undefined) return false;
+  if (!(JUNK_BUCKETS as readonly string[]).includes(choice)) return false;
+  return confidence >= JEV_ARCHIVE_CONFIDENCE_MIN && ageHours >= JEV_ARCHIVE_MIN_AGE_HOURS;
+}
+
+// ── the loops (one call per session, fail-open per session) ──────────────────
+
+/** Status of a loop pass: ran | unavailable (no key — the fail-open config)
+ * | disabled (the off-switch). The first call's failure mode decides; no
+ * call is ever made after unavailability is known. */
+export type JevPassStatus = "ran" | "unavailable" | "disabled";
+
+/** One rule-unclassified session the residual loop judges. `ageHours` is the
+ * FIXED 48 h gate input (now − time_updated), never the scan cutoff. */
+export interface ResidualSession {
+  id: string;
+  features: SessionFeaturesLite;
+  ageHours: number;
+}
+
+/** Per-session residual verdict: the Choice read (with its full probability
+ * distribution — the calibration battery Briers it), or the honest error
+ * that failed it (never both, never neither). */
+export interface ResidualVerdict {
+  choice?: string;
+  confidence?: number;
+  probabilities?: Record<string, number>;
+  error?: string;
+}
+
+/** ONE Jev Choice per rule-unclassified session (the classifier residual).
+ * Sessions already in a deterministic junk bucket never reach this loop —
+ * the caller passes the residual only (residual-only wiring). */
+export async function jevJunkResidual(
+  sessions: ResidualSession[],
+  deps: CurationDeps = {},
+): Promise<{ status: JevPassStatus; verdicts: Record<string, ResidualVerdict> }> {
+  const verdicts: Record<string, ResidualVerdict> = {};
+  for (const s of sessions) {
+    const { question, state } = junkResidualQuestion(s.features);
+    const res = await askJev({ junk_bucket: question }, state, { sessionId: s.id, deps });
+    if (!res.ok) {
+      if (res.reason === "disabled" || res.reason === "key-missing") return { status: res.reason === "disabled" ? "disabled" : "unavailable", verdicts };
+      verdicts[s.id] = { error: res.error };
+      continue;
+    }
+    const answer = res.answers.junk_bucket;
+    if (answer === undefined || answer.type !== "choice") {
+      verdicts[s.id] = { error: "no choice answer for junk_bucket" };
+      continue;
+    }
+    verdicts[s.id] = { choice: answer.choice, confidence: answer.confidence, ...(answer.probabilities !== undefined ? { probabilities: answer.probabilities } : {}) };
+  }
+  return { status: "ran", verdicts };
+}
+
+/** The last-text excerpt cap — the noul fold stays digest-sized. */
+const NOUL_STATE_TEXT_CHARS = 400;
+
+/** One digest candidate for the onset thread-Noul pass. */
+export interface NoulCandidate {
+  id: string;
+  title: string;
+  lastAssistantText: string;
+  pendingTodos: number;
+}
+
+/** The thread-Noul question: "does this session still have an open thread?" */
+export function threadNoulQuestion(c: NoulCandidate): { question: JevQuestion; state: Record<string, unknown> } {
+  return {
+    question: {
+      type: "noul",
+      instructions: "Does this chat session still have an open thread — an unfinished step, a decision the user owes, or documented pending work?",
+      criteria: {
+        true: "the session awaits a user decision, ended mid-action, or carries pending documented work",
+        false: "the session wrapped up — verdict delivered, nothing owed",
+      },
+    },
+    state: {
+      title: c.title,
+      last_text: c.lastAssistantText.slice(0, NOUL_STATE_TEXT_CHARS),
+      pending_todos: c.pendingTodos,
+    },
+  };
+}
+
+/** ONE thread-Noul per digest candidate → the promotion map the onset digest
+ * consumes. A failed candidate is absent from the map (never a guessed 0);
+ * unavailable/disabled yields the EMPTY map — the digest degrades to today. */
+export async function jevThreadNouls(
+  candidates: NoulCandidate[],
+  deps: CurationDeps = {},
+): Promise<{ status: JevPassStatus; nouls: Record<string, number> }> {
+  const nouls: Record<string, number> = {};
+  for (const c of candidates) {
+    const { question, state } = threadNoulQuestion(c);
+    const res = await askJev({ has_open_thread: question }, state, { sessionId: c.id, deps });
+    if (!res.ok) {
+      if (res.reason === "disabled" || res.reason === "key-missing") return { status: res.reason === "disabled" ? "disabled" : "unavailable", nouls };
+      continue;
+    }
+    const answer = res.answers.has_open_thread;
+    if (answer !== undefined && answer.type === "noul") nouls[c.id] = answer.noul;
+  }
+  return { status: "ran", nouls };
+}
diff --git a/packages/amico-run/src/session_junk.ts b/packages/amico-run/src/session_junk.ts
index da9cf9c2..e03c1d47 100644
--- a/packages/amico-run/src/session_junk.ts
+++ b/packages/amico-run/src/session_junk.ts
@@ -48,7 +48,7 @@ export const GREETING_TITLE_VOCABULARY = [
   "new session",
 ] as const;
 
-function isGreetingTitle(title: string): boolean {
+export function isGreetingTitle(title: string): boolean {
   const t = title.toLowerCase();
   return GREETING_TITLE_VOCABULARY.some((word) => new RegExp(`\\b${word}\\b`).test(t));
 }
diff --git a/packages/amico-run/src/session_retention.ts b/packages/amico-run/src/session_retention.ts
index ca261abb..fecd681e 100644
--- a/packages/amico-run/src/session_retention.ts
+++ b/packages/amico-run/src/session_retention.ts
@@ -25,7 +25,7 @@ export const DEFAULT_ARCHIVE_DAYS = 30;
  *  silent this long before the nightly curation relocates it. */
 export const DEFAULT_AUTOARCHIVE_HOURS = 48;
 
-function amicodeOpsDir(env: NodeJS.ProcessEnv): string {
+export function amicodeOpsDir(env: NodeJS.ProcessEnv): string {
   const v = env.AMICODE_OPS_DIR;
   return v && v.trim() !== "" ? v : join(homedir(), ".amico", "amicode");
 }
diff --git a/packages/amico-run/src/sessions_verb.ts b/packages/amico-run/src/sessions_verb.ts
index 8756f42a..9ad708eb 100644
--- a/packages/amico-run/src/sessions_verb.ts
+++ b/packages/amico-run/src/sessions_verb.ts
@@ -20,10 +20,11 @@
 // The driver is the python3 stdlib sqlite3 bridge (src/sqlite_bridge.ts) —
 // NOT node:sqlite, which does not exist on the repo's CI node (20.x). See the
 // bridge module header for the full rationale.
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
+  amicodeOpsDir,
   readArchiveDays,
   readAutoArchiveHours,
   renderSessionIndex,
@@ -32,7 +33,9 @@ import {
   writeAutoArchiveHours,
   type IndexSession,
 } from "./session_retention.js";
-import { classifySession, type SessionFeatures } from "./session_junk.js";
+import { classifySession, isGreetingTitle, type SessionFeatures } from "./session_junk.js";
+import { jevArchiveAdmits, jevJunkResidual, jevThreadNouls, type JevPassStatus, type NoulCandidate, type ResidualSession, type ResidualVerdict } from "./jev_curation.js";
+import { jevDisabled } from "./jev_client.js";
 import { sqliteBatch, type BridgeStatement } from "./sqlite_bridge.js";
 import type { VerbResult } from "./verbs.js";
 
@@ -192,7 +195,17 @@ const AUTOARCHIVE_FEATURES_SQL = `
   WHERE s.time_archived IS NULL AND s.time_updated < ?
   ORDER BY s.time_updated DESC, s.id`;
 
-function sessionsAutoarchive(argv: string[], env: NodeJS.ProcessEnv): VerbResult {
+// ── autoarchive (#1304 + #1311): classification-gated curation with the Jev
+//    classifier residual as the confidence-gated middle layer ───────────────
+
+/** The jev residual pass over rule-unclassified sessions — injectable so the
+ * suite runs hermetically (the default is the real client, key read at call
+ * time from the secrets path; disabled/unavailable → fail-open). */
+export interface AutoarchiveDeps {
+  jev?: (sessions: ResidualSession[]) => Promise<{ status: JevPassStatus; verdicts: Record<string, ResidualVerdict> }>;
+}
+
+export async function sessionsAutoarchive(argv: string[], env: NodeJS.ProcessEnv, deps: AutoarchiveDeps = {}): Promise<VerbResult> {
   const dbPath = resolveSessionDb(argv);
   if (!existsSync(dbPath)) return fail(`session DB not found: ${dbPath}`);
   const hours = flagValue(argv, "--hours") ? Number(flagValue(argv, "--hours")) : readAutoArchiveHours(env);
@@ -217,22 +230,32 @@ function sessionsAutoarchive(argv: string[], env: NodeJS.ProcessEnv): VerbResult
       assistant_message_count: Number(r.assistant_message_count),
       todo_count: Number(r.todo_count),
     };
-    return { id: String(r.id), bucket: classifySession(features) };
+    return { id: String(r.id), bucket: classifySession(features), features, time_updated: Number(r.time_updated) };
   });
   const buckets = judged.reduce<Record<string, number>>((acc, j) => {
     acc[j.bucket] = (acc[j.bucket] ?? 0) + 1;
     return acc;
   }, {});
-  // Junk buckets only — curation archives the deterministic noise, never a
-  // substantive session (the classifier's closed-set default guards work).
+  // Deterministic junk first — the #1304 rule, first and untouched. Jev NEVER
+  // re-judges a session the rules already classified (residual-only wiring).
   const ids = judged.filter((j) => j.bucket !== "substantive").map((j) => j.id);
 
-  if (apply && ids.length > 0) {
+  // ── the #1311 residual: the middle layer, additive and fail-open ─────────
+  // Sessions the rules left unclassified (substantive = no junk rule fired)
+  // get ONE Jev Choice; a junk-bucket read at p ≥ 0.95 AND age ≥ 48 h (the
+  // FIXED gate, never the scan cutoff) admits to the archive path as an OR.
+  // The off-switch (AMICO_JEV_DISABLED) skips the pass entirely — the output
+  // is byte-identical to the deterministic shape (zero behavioral delta).
+  const jevReport: Record<string, unknown> | undefined = await runJunkResidual(judged, env, deps);
+  const admittedIds = Array.isArray(jevReport?.admitted_ids) ? (jevReport.admitted_ids as string[]) : [];
+  const allIds = [...ids, ...admittedIds];
+
+  if (apply && allIds.length > 0) {
     try {
       sqliteBatch(dbPath, "rw", [
         {
-          sql: `UPDATE session SET time_archived = ? WHERE time_archived IS NULL AND id IN (${ids.map(() => "?").join(",")})`,
-          params: [Date.now(), ...ids],
+          sql: `UPDATE session SET time_archived = ? WHERE time_archived IS NULL AND id IN (${allIds.map(() => "?").join(",")})`,
+          params: [Date.now(), ...allIds],
         },
       ]);
     } catch (e) {
@@ -250,10 +273,164 @@ function sessionsAutoarchive(argv: string[], env: NodeJS.ProcessEnv): VerbResult
       cutoff_iso: new Date(cutoff).toISOString(),
       scanned: judged.length,
       buckets,
-      candidates: ids.length,
-      candidate_ids: ids.slice(0, 50),
-      archived: apply ? ids.length : 0,
+      candidates: allIds.length,
+      candidate_ids: allIds.slice(0, 50),
+      archived: apply ? allIds.length : 0,
       note: apply ? undefined : "dry-run: nothing written — pass --apply to stamp time_archived",
+      ...(jevReport !== undefined ? { jev: jevReport } : {}),
+    },
+    code: 0,
+  };
+}
+
+/** The residual step, isolated: returns the jev report block (undefined when
+ * the path is disabled — the zero-delta off-switch), never throws (fail-open:
+ * an error report still archives the deterministic candidates). */
+async function runJunkResidual(
+  judged: { id: string; bucket: string; features: SessionFeatures; time_updated: number }[],
+  env: NodeJS.ProcessEnv,
+  deps: AutoarchiveDeps,
+): Promise<Record<string, unknown> | undefined> {
+  if (jevDisabled(env)) return undefined;
+  const residual: ResidualSession[] = judged
+    .filter((j) => j.bucket === "substantive")
+    .map((j) => ({ id: j.id, features: j.features, ageHours: (Date.now() - j.time_updated) / 3_600_000 }));
+  if (residual.length === 0) return { status: "ran", consulted: 0, admitted: 0, admitted_ids: [] };
+  try {
+    const pass = deps.jev !== undefined ? await deps.jev(residual) : await jevJunkResidual(residual, { env });
+    if (pass.status !== "ran") return { status: pass.status, consulted: 0, admitted: 0, admitted_ids: [] };
+    const admittedIds = residual
+      .filter((s) => jevArchiveAdmits(pass.verdicts[s.id]?.choice, pass.verdicts[s.id]?.confidence ?? 0, s.ageHours))
+      .map((s) => s.id);
+    return { status: "ran", consulted: residual.length, admitted: admittedIds.length, admitted_ids: admittedIds };
+  } catch (e) {
+    return { status: "error", error: e instanceof Error ? e.message : String(e), consulted: 0, admitted: 0, admitted_ids: [] };
+  }
+}
+
+// ── thread-noul (#1311): the onset digest's noul-map pass ────────────────────
+// The amico-run half of the onset thread-Noul seam: sweep the digest window,
+// ONE Jev noul per candidate (junk titles pre-filtered by the SAME
+// deterministic vocabulary the classifier uses — the middle layer never
+// pays for obvious noise), and write the derived map (thread-nouls.json in
+// the ops dir) the plugin's digest READS as an input feature. The digest's
+// deterministic derivation never calls Jev; this pass is the only spender.
+// DRY-RUN by default (the S2 convention); --apply writes the map.
+
+/** The sweep window matches the digest's (open_threads AMICODE_OPEN_THREADS_
+ * WINDOW_DAYS default 14). */
+export const DEFAULT_THREAD_NOUL_WINDOW_DAYS = 14;
+
+const THREAD_NOUL_CANDIDATES_SQL = `
+  SELECT s.id, s.title,
+    (SELECT json_extract(p.data, '$.text') FROM part p JOIN message m ON m.id = p.message_id
+      WHERE p.session_id = s.id AND json_extract(m.data, '$.role') = 'assistant'
+        AND json_extract(p.data, '$.type') = 'text'
+        AND length(json_extract(p.data, '$.text')) > 0
+      ORDER BY p.time_created DESC LIMIT 1) AS last_text,
+    (SELECT COUNT(*) FROM todo t WHERE t.session_id = s.id
+      AND t.status != 'completed') AS todo_count
+  FROM session s
+  WHERE s.parent_id IS NULL AND s.time_archived IS NULL AND s.time_created > ?
+  ORDER BY s.time_created DESC`;
+
+/** The noul pass's injectable seam (the same shape autoarchive's residual takes). */
+export interface ThreadNoulDeps {
+  jev?: (candidates: NoulCandidate[]) => Promise<{ status: JevPassStatus; nouls: Record<string, number> }>;
+}
+
+export async function sessionsThreadNoul(argv: string[], env: NodeJS.ProcessEnv, deps: ThreadNoulDeps = {}): Promise<VerbResult> {
+  const dbPath = resolveSessionDb(argv);
+  if (!existsSync(dbPath)) return fail(`session DB not found: ${dbPath}`);
+  const days = flagValue(argv, "--days") ? Number(flagValue(argv, "--days")) : DEFAULT_THREAD_NOUL_WINDOW_DAYS;
+  if (!Number.isInteger(days) || days < 1) return fail(`--days must be a positive integer, got ${days}`);
+  const apply = hasFlag(argv, "--apply");
+  const cutoff = Date.now() - days * 86_400_000;
+  const mapPath = join(amicodeOpsDir(env), "thread-nouls.json");
+
+  if (jevDisabled(env)) {
+    return {
+      json: { verb: "sessions", subcommand: "thread-noul", dry_run: !apply, days, disabled: true, note: "jev path disabled (AMICO_JEV_DISABLED) — zero delta; no map written" },
+      code: 0,
+    };
+  }
+
+  let batch;
+  try {
+    batch = sqliteBatch(dbPath, "ro", [{ sql: THREAD_NOUL_CANDIDATES_SQL, params: [cutoff] }]);
+  } catch (e) {
+    return fail(e instanceof Error ? e.message : String(e));
+  }
+
+  // The deterministic pre-filter: greeting-vocabulary titles never reach the
+  // middle layer (the classifier's noise vocabulary — same words, one source).
+  const candidates: NoulCandidate[] = batch.results[0].rows
+    .map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      lastAssistantText: r.last_text === null || r.last_text === undefined ? "" : String(r.last_text),
+      pendingTodos: Number(r.todo_count),
+    }))
+    .filter((c) => !isGreetingTitle(c.title));
+
+  let pass: { status: JevPassStatus | "error"; nouls: Record<string, number> };
+  try {
+    pass = deps.jev !== undefined ? await deps.jev(candidates) : await jevThreadNouls(candidates, { env });
+  } catch (e) {
+    pass = { status: "error", nouls: {} };
+    return {
+      json: {
+        verb: "sessions",
+        subcommand: "thread-noul",
+        dry_run: !apply,
+        days,
+        window_days: days,
+        candidates: candidates.length,
+        status: "error",
+        error: e instanceof Error ? e.message : String(e),
+        map_path: mapPath,
+        note: "fail-open: the noul pass crashed; no map written; the digest degrades to today",
+      },
+      code: 0,
+    };
+  }
+
+  if (pass.status !== "ran") {
+    return {
+      json: {
+        verb: "sessions",
+        subcommand: "thread-noul",
+        dry_run: !apply,
+        days,
+        window_days: days,
+        candidates: candidates.length,
+        status: pass.status,
+        map_path: mapPath,
+        note: "fail-open: the middle layer is unavailable; no map written; the digest degrades to today",
+      },
+      code: 0,
+    };
+  }
+
+  if (apply) {
+    const tmpMap = `${mapPath}.tmp-${process.pid}`;
+    mkdirSync(dirname(mapPath), { recursive: true });
+    writeFileSync(tmpMap, JSON.stringify({ schema_version: 1, generated_at: new Date().toISOString(), entries: pass.nouls }, null, 2) + "\n");
+    renameSync(tmpMap, mapPath);
+  }
+
+  return {
+    json: {
+      verb: "sessions",
+      subcommand: "thread-noul",
+      dry_run: !apply,
+      days,
+      window_days: days,
+      candidates: candidates.length,
+      status: "ran",
+      judged: Object.keys(pass.nouls).length,
+      map_path: apply ? mapPath : undefined,
+      note: apply ? undefined : "dry-run: nothing written — pass --apply to write the derived thread-nouls map",
     },
     code: 0,
   };
@@ -375,7 +552,9 @@ export async function sessionsVerb(argv: string[]): Promise<VerbResult> {
     case "archive":
       return sessionsArchive(rest, env);
     case "autoarchive":
-      return sessionsAutoarchive(rest, env);
+      return await sessionsAutoarchive(rest, env);
+    case "thread-noul":
+      return await sessionsThreadNoul(rest, env);
     case "restore":
       return sessionsRestore(rest);
     case "index":
@@ -388,7 +567,7 @@ export async function sessionsVerb(argv: string[]): Promise<VerbResult> {
           verb: "sessions",
           error: `unknown subcommand ${sub ? `"${sub}"` : "(none)"}`,
           usage:
-            "amico sessions list [--archived] [--limit <n>] [--cursor <c>] [--db <path>]  |  amico sessions archive [--days <n>] [--apply]  |  amico sessions autoarchive [--hours <n>] [--apply]  |  amico sessions restore <id>  |  amico sessions index [--out <path>]  |  amico sessions prefs [--days <n>] [--autoarchive-hours <n>]",
+            "amico sessions list [--archived] [--limit <n>] [--cursor <c>] [--db <path>]  |  amico sessions archive [--days <n>] [--apply]  |  amico sessions autoarchive [--hours <n>] [--apply]  |  amico sessions thread-noul [--days <n>] [--apply]  |  amico sessions restore <id>  |  amico sessions index [--out <path>]  |  amico sessions prefs [--days <n>] [--autoarchive-hours <n>]",
         },
         code: 64,
       };
diff --git a/packages/amico-run/test/fixtures/jev/calibration-2026-09-20.json b/packages/amico-run/test/fixtures/jev/calibration-2026-09-20.json
new file mode 100644
index 00000000..9b56560a
--- /dev/null
+++ b/packages/amico-run/test/fixtures/jev/calibration-2026-09-20.json
@@ -0,0 +1,55 @@
+{
+  "calibration_set": "2026-09-20 session-curation sweep (spec-20260920-session-curation.md §Calibration)",
+  "model": "jev-1.13.0",
+  "notes": "Six real sweep sessions: two junk, one borderline (fleet-smoke — the single bucket mismatch, action-irrelevant: both buckets archive), three substantive. Recorded answers are the 2026-09-20 live run (5/6 bucket agreement; noul spread 0.05 junk → 0.71 blocked-on-user → 0.91 live campaign; ~300-350 ms, ~13 µ$/session). Features are the classifier fold as swept; last_text is the ~3KB-capped excerpt the noul question was asked over. recorded.noul absent where the spec did not record one.",
+  "entries": [
+    {
+      "session_id": "ses_greet_1",
+      "features": { "title": "Friendly greeting", "user_message_count": 1, "user_text_chars": 12, "assistant_message_count": 2, "todo_count": 0 },
+      "last_text": "Hello! Ready when you are — what would you like to work on?",
+      "hand_bucket": "junk-greeting",
+      "hand_has_thread": false,
+      "recorded": { "choice": "junk-greeting", "confidence": 1.0, "noul": 0.05 }
+    },
+    {
+      "session_id": "ses_greet_2",
+      "features": { "title": "Howdy greeting", "user_message_count": 1, "user_text_chars": 8, "assistant_message_count": 3, "todo_count": 0 },
+      "last_text": "Howdy! Ask me anything.",
+      "hand_bucket": "junk-greeting",
+      "hand_has_thread": false,
+      "recorded": { "choice": "junk-greeting", "confidence": 1.0, "noul": 0.08 }
+    },
+    {
+      "session_id": "ses_smoke",
+      "features": { "title": "fleet-smoke", "user_message_count": 1, "user_text_chars": 15, "assistant_message_count": 3, "todo_count": 0 },
+      "last_text": "smoke run complete — 4/4 checks green.",
+      "hand_bucket": "junk-greeting",
+      "hand_has_thread": false,
+      "recorded": { "choice": "dead-cast", "confidence": 0.75 }
+    },
+    {
+      "session_id": "ses_bugreport",
+      "features": { "title": "Bug report: panel sessions disappear", "user_message_count": 6, "user_text_chars": 400, "assistant_message_count": 12, "todo_count": 0 },
+      "last_text": "The fix is staged on the branch — waiting on your confirmation before I merge it.",
+      "hand_bucket": "substantive",
+      "hand_has_thread": true,
+      "recorded": { "choice": "substantive", "confidence": 1.0, "noul": 0.71 }
+    },
+    {
+      "session_id": "ses_campaign",
+      "features": { "title": "Session cleanup & curation planning", "user_message_count": 11, "user_text_chars": 1400, "assistant_message_count": 25, "todo_count": 3 },
+      "last_text": "The sweep is recorded and the integration contract is drafted; the Jev middle layer is the next slice.",
+      "hand_bucket": "substantive",
+      "hand_has_thread": true,
+      "recorded": { "choice": "substantive", "confidence": 1.0, "noul": 0.91 }
+    },
+    {
+      "session_id": "ses_engine_compare",
+      "features": { "title": "SoL-Pi vs telaio autoresearch engine comparison", "user_message_count": 10, "user_text_chars": 1200, "assistant_message_count": 20, "todo_count": 2 },
+      "last_text": "Both engines are mapped; the routing decision rides on which loop protocol fits telaio's task rows.",
+      "hand_bucket": "substantive",
+      "hand_has_thread": true,
+      "recorded": { "choice": "substantive", "confidence": 1.0 }
+    }
+  ]
+}
diff --git a/packages/amico-run/test/jev_calibration.test.ts b/packages/amico-run/test/jev_calibration.test.ts
new file mode 100644
index 00000000..34c9e678
--- /dev/null
+++ b/packages/amico-run/test/jev_calibration.test.ts
@@ -0,0 +1,159 @@
+// jev_calibration — issue #1311: the calibration BATTERY (the curation spec's
+// discipline: thresholds are evaluated on our data, never cookbook). The pure
+// graders below reproduce the 2026-09-20 sweep numbers from the hand-labeled
+// fixture (test/fixtures/jev/calibration-2026-09-20.json) and are what the
+// live harness (test/slow/jev_calibration.test.ts — network, opt-in env, NOT
+// part of the unit suite) replays the set through on demand.
+// Run: `pnpm --filter @amicode/amico-run test`.
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  gradeChoiceBattery,
+  gradeNoulBattery,
+  runCalibrationBattery,
+  type CalibrationEntry,
+} from "../src/jev_calibration.js";
+
+const FIXTURE = JSON.parse(
+  readFileSync(join(__dirname, "fixtures", "jev", "calibration-2026-09-20.json"), "utf8"),
+) as { entries: CalibrationEntry[] };
+
+/** The recorded answers as the battery saw them on 2026-09-20 (provenance in the fixture). */
+function recordedAnswers(entries: CalibrationEntry[]): Record<string, { choice?: string; confidence?: number; noul?: number }> {
+  const out: Record<string, { choice?: string; confidence?: number; noul?: number }> = {};
+  for (const e of entries) {
+    if (e.recorded?.choice !== undefined) out[e.session_id] = { choice: e.recorded.choice, confidence: e.recorded.confidence };
+  }
+  return out;
+}
+
+function recordedNouls(entries: CalibrationEntry[]): Record<string, number> {
+  const out: Record<string, number> = {};
+  for (const e of entries) {
+    if (e.recorded?.noul !== undefined) out[e.session_id] = e.recorded.noul;
+  }
+  return out;
+}
+
+describe("the 2026-09-20 calibration battery — recorded answers graded against hand labels", () => {
+  it("grades the six-session set: 5/6 bucket agreement, the single mismatch action-irrelevant", () => {
+    const g = gradeChoiceBattery(FIXTURE.entries, recordedAnswers(FIXTURE.entries));
+    expect(g.judged).toBe(6);
+    expect(g.agree).toBe(5);
+    expect(g.mismatches).toEqual([
+      { session_id: "ses_smoke", hand: "junk-greeting", jev: "dead-cast", note: "action-irrelevant: both buckets archive" },
+    ]);
+    // the ACTION matrix agrees 6/6 — the mismatch never changes what would happen
+    expect(g.action_agree).toBe(6);
+  });
+
+  it("grades the noul spread: junk low, substance high — min 0.05, max 0.91", () => {
+    const g = gradeNoulBattery(FIXTURE.entries, recordedNouls(FIXTURE.entries));
+    expect(g.judged).toBe(4); // the four nouls the spec recorded
+    expect(g.spread.min).toBeCloseTo(0.05, 5);
+    expect(g.spread.max).toBeCloseTo(0.91, 5);
+    expect(g.brier).toBeCloseTo(0.0252750, 6);
+  });
+
+  it("computes multiclass choice Brier over the closed option set when probabilities are present", () => {
+    const entries = FIXTURE.entries.slice(0, 1); // one junk-greeting session
+    const brier = gradeChoiceBattery(entries, {
+      ses_greet_1: { choice: "junk-greeting", confidence: 0.9, probabilities: { "junk-greeting": 0.9, substantive: 0.1 } },
+    }).brier;
+    // (0.9−1)² + (0.1−0)² across the two declared options; the rest are 0−0
+    expect(brier).toBeCloseTo(0.02, 6);
+  });
+
+  it("reports choice Brier as null (with reason) when any judged answer lacks probabilities", () => {
+    const g = gradeChoiceBattery(FIXTURE.entries, recordedAnswers(FIXTURE.entries));
+    expect(g.brier).toBeNull();
+    expect(g.brier_reason).toMatch(/probabilities/);
+  });
+
+  it("judges only sessions with an answer — a session the client missed is absent, never guessed", () => {
+    const g = gradeChoiceBattery(FIXTURE.entries, { ses_greet_1: { choice: "junk-greeting", confidence: 1.0 } });
+    expect(g.judged).toBe(1);
+    expect(g.agree).toBe(1);
+  });
+});
+
+// ── the battery RUNNER end-to-end (stub transport — the slow tier replays live) ──
+describe("runCalibrationBattery — both loops + grading in one pass", () => {
+  it("replays every entry through the choice and noul loops and grades (hermetic stub transport)", async () => {
+    const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+    const { tmpdir } = await import("node:os");
+    const root = mkdtempSync(join(tmpdir(), "amico-jev-bat-"));
+    try {
+      const key = join(root, "key");
+      writeFileSync(key, "k_test_bat", { mode: 0o600 });
+      // answer by hand bucket: junk sessions read junk with 0.9, substance reads substantive with 0.9;
+      // nouls follow the sweep shape (junk low, substance high)
+      const transport = async (_url: string, init: { body: string }) => {
+        const body = JSON.parse(init.body) as { state: { title?: string }; questions: Record<string, { type: string }> };
+        const [questionId, question] = Object.entries(body.questions)[0];
+        const answer =
+          question.type === "choice"
+            ? { type: "choice", choice: body.state.title === "fleet-smoke" ? "dead-cast" : body.state.title!.match(/greeting/i) ? "junk-greeting" : "substantive", confidence: 0.9 }
+            : { type: "noul", noul: body.state.title!.match(/greeting|smoke/i) ? 0.07 : 0.8 };
+        return { status: 200, text: async () => JSON.stringify({ model: "jev-test", answers: { [questionId]: answer }, usage: { input_tokens: 500, output_tokens: 21 } }) };
+      };
+
+      const battery = await runCalibrationBattery(FIXTURE.entries, {
+        env: { AMICO_TYPESAFE_KEY_FILE: key, AMICO_TYPESAFE_RECEIPTS: join(root, "receipts.jsonl") },
+        transport,
+      });
+
+      expect(battery.status).toBe("ran");
+      // 5/6 bucket agreement (fleet-smoke reads dead-cast, action-irrelevant), 6/6 action agreement
+      expect(battery.choice.judged).toBe(6);
+      expect(battery.choice.agree).toBe(5);
+      expect(battery.choice.action_agree).toBe(6);
+      // all six nouls answered: junk ~0.07, substance ~0.8
+      expect(battery.noul.judged).toBe(6);
+      expect(battery.noul.spread.min).toBeCloseTo(0.07, 5);
+      expect(battery.noul.spread.max).toBeCloseTo(0.8, 5);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("no key → status unavailable, nothing judged (the harness degrades honestly, never fabricates)", async () => {
+    const battery = await runCalibrationBattery(FIXTURE.entries, { env: { AMICO_TYPESAFE_KEY_FILE: "/nonexistent/key", AMICO_TYPESAFE_RECEIPTS: "/nonexistent/r.jsonl" } });
+    expect(battery.status).toBe("unavailable");
+    expect(battery.choice.judged).toBe(0);
+    expect(battery.noul.judged).toBe(0);
+  });
+
+  it("carries the choice probabilities THROUGH the residual verdicts so the live battery can Brier them", async () => {
+    const { mkdtempSync, rmSync, writeFileSync } = await import("node:fs");
+    const { tmpdir } = await import("node:os");
+    const root = mkdtempSync(join(tmpdir(), "amico-jev-prob-"));
+    try {
+      const key = join(root, "key");
+      writeFileSync(key, "k_test_prob", { mode: 0o600 });
+      const transport = async (_url: string, init: { body: string }) => {
+        const body = JSON.parse(init.body) as { state: { title?: string }; questions: Record<string, { type: string }> };
+        const [questionId, question] = Object.entries(body.questions)[0];
+        const answer =
+          question.type === "choice"
+            ? { type: "choice", choice: body.state.title === "fleet-smoke" ? "dead-cast" : body.state.title!.match(/greeting/i) ? "junk-greeting" : "substantive", confidence: 0.9, probabilities: body.state.title!.match(/greeting|smoke/i) ? { "junk-greeting": 0.5, "dead-cast": 0.4, substantive: 0.1 } : { substantive: 0.9, unclassified: 0.1 } }
+            : { type: "noul", noul: 0.07 };
+        return { status: 200, text: async () => JSON.stringify({ model: "jev-test", answers: { [questionId]: answer }, usage: { input_tokens: 500, output_tokens: 21 } }) };
+      };
+
+      const battery = await runCalibrationBattery(FIXTURE.entries, {
+        env: { AMICO_TYPESAFE_KEY_FILE: key, AMICO_TYPESAFE_RECEIPTS: join(root, "receipts.jsonl") },
+        transport,
+      });
+
+      // probabilities present → choice Brier is COMPUTED (not null)
+      expect(battery.choice.brier).not.toBeNull();
+      expect(battery.choice.brier_reason).toBeUndefined();
+      expect(battery.choice.brier).toBeGreaterThan(0);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/amico-run/test/jev_client.test.ts b/packages/amico-run/test/jev_client.test.ts
new file mode 100644
index 00000000..af7ae2ae
--- /dev/null
+++ b/packages/amico-run/test/jev_client.test.ts
@@ -0,0 +1,222 @@
+// jev_client — issue #1311 (slice of #1301 session curation): the ONE thin
+// Jev client (TypeSafe System One decision model) for amicode's curation
+// seams. The contract of record is the live-verified wire shape (2026-09-20,
+// harmoniqs/amicode#1311): POST https://api.typesafe.ai/v1/systemone,
+// Bearer key, {"model":"jev-latest","state":…,"questions":{…}}; answers
+// {"<id>": {"type":"choice","choice":…,"confidence":…,"probabilities":…} |
+// {"type":"noul","noul":…}} plus {"model":"jev-x.y.z","usage":{…}}.
+//
+// Hermetic by construction: the transport is INJECTABLE (tests stub it — no
+// network), the key path rides $AMICO_TYPESAFE_KEY_FILE (tests point it at
+// temp files — the real key at ~/.amico/typesafe/key is never read here),
+// and the receipts journal is injectable (tests write to temp dirs).
+// Run: `pnpm --filter @amicode/amico-run test`.
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { askJev, jevKeyFile, type JevTransport } from "../src/jev_client.js";
+
+/** The receipt lines a run has appended to its journal. */
+function receiptLines(path: string): Record<string, unknown>[] {
+  return readFileSync(path, "utf8")
+    .trim()
+    .split("\n")
+    .map((l) => JSON.parse(l) as Record<string, unknown>);
+}
+
+const NOUL_QUESTION = {
+  type: "noul" as const,
+  instructions: "Does this session still have an open thread?",
+  criteria: { true: "the session awaits a decision or an unfinished step", false: "the session is wrapped up" },
+};
+
+/** A hermetic world: temp key file (never the live ~/.amico/typesafe/key) +
+ * temp receipts journal. */
+function makeWorld() {
+  const root = mkdtempSync(join(tmpdir(), "amico-jev-"));
+  const key = join(root, "key");
+  writeFileSync(key, "k_test_deadbeef00", { mode: 0o600 });
+  const receipts = join(root, "receipts", "receipts.jsonl");
+  return { root, key, receipts };
+}
+
+const CHOICE_QUESTION = {
+  type: "choice" as const,
+  instructions: "Classify this chat session into exactly one bucket.",
+  criteria: {
+    "junk-greeting": "greeting-titled, minimal user text",
+    substantive: "real work",
+    unclassified: "none of the above fits",
+  },
+};
+
+describe("jev client — the confirmed wire contract (stub transport, no network)", () => {
+  let w: ReturnType<typeof makeWorld>;
+  beforeEach(() => {
+    w = makeWorld();
+  });
+  afterEach(() => rmSync(w.root, { recursive: true, force: true }));
+
+  it("round-trips a choice question: bearer key from the secrets path, model jev-latest, answers parsed", async () => {
+    const calls: { url: string; headers: Record<string, string>; body: unknown }[] = [];
+    const transport: JevTransport = async (url, init) => {
+      calls.push({ url, headers: init.headers, body: JSON.parse(init.body) });
+      return {
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            model: "jev-1.13.0",
+            answers: { junk_bucket: { type: "choice", choice: "junk-greeting", confidence: 0.96, probabilities: { "junk-greeting": 0.96, substantive: 0.04 } } },
+            usage: { input_tokens: 500, output_tokens: 21 },
+          }),
+      };
+    };
+
+    const res = await askJev({ junk_bucket: CHOICE_QUESTION }, { title: "hello", user_text_chars: 12 }, {
+      sessionId: "ses_1",
+      deps: { env: { AMICO_TYPESAFE_KEY_FILE: w.key }, transport, receiptsPath: w.receipts },
+    });
+
+    expect(res.ok).toBe(true);
+    if (!res.ok) return;
+    expect(res.model).toBe("jev-1.13.0");
+    expect(res.answers.junk_bucket).toEqual({ type: "choice", choice: "junk-greeting", confidence: 0.96, probabilities: { "junk-greeting": 0.96, substantive: 0.04 } });
+    expect(res.usage).toEqual({ input_tokens: 500, output_tokens: 21 });
+
+    // the REQUEST is the confirmed shape: endpoint, bearer, model, state, questions
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe("https://api.typesafe.ai/v1/systemone");
+    expect(calls[0].headers.Authorization).toBe("Bearer k_test_deadbeef00");
+    expect(calls[0].headers["Content-Type"]).toBe("application/json");
+    expect(calls[0].body).toEqual({
+      model: "jev-latest",
+      state: { title: "hello", user_text_chars: 12 },
+      questions: { junk_bucket: CHOICE_QUESTION },
+    });
+  });
+
+  it("resolves the key path $AMICO_TYPESAFE_KEY_FILE → ~/.amico/typesafe/key (the secrets posture)", () => {
+    expect(jevKeyFile({ AMICO_TYPESAFE_KEY_FILE: "/custom/key" })).toBe("/custom/key");
+    expect(jevKeyFile({})).toBe(join(process.env.HOME ?? "", ".amico", "typesafe", "key"));
+  });
+});
+
+// ── AC 1: every call logged as ONE JSON decision record (the S2 receipt pattern) ──
+describe("jev client — decision-record receipts", () => {
+  let w: ReturnType<typeof makeWorld>;
+  beforeEach(() => {
+    w = makeWorld();
+  });
+  afterEach(() => rmSync(w.root, { recursive: true, force: true }));
+
+  const env = () => ({ AMICO_TYPESAFE_KEY_FILE: w.key, AMICO_TYPESAFE_RECEIPTS: w.receipts });
+
+  it("a successful choice call appends exactly one line: primitive, verdict, confidence, latency, model, state size, ts", async () => {
+    const transport: JevTransport = async () => ({
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          model: "jev-1.13.0",
+          answers: { junk_bucket: { type: "choice", choice: "junk-greeting", confidence: 0.96 } },
+          usage: { input_tokens: 500, output_tokens: 21 },
+        }),
+    });
+
+    const res = await askJev({ junk_bucket: CHOICE_QUESTION }, { title: "hello" }, { sessionId: "ses_r", deps: { env: env(), transport, now: () => 1_000 } });
+    expect(res.ok).toBe(true);
+
+    const lines = receiptLines(w.receipts);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toMatchObject({
+      receipt_version: 1,
+      kind: "jev-decision",
+      session_id: "ses_r",
+      primitive: "choice",
+      state_bytes: JSON.stringify({ title: "hello" }).length,
+      model: "jev-1.13.0",
+      usage: { input_tokens: 500, output_tokens: 21 },
+    });
+    expect(lines[0].verdicts).toEqual([{ id: "junk_bucket", choice: "junk-greeting", confidence: 0.96 }]);
+    expect(lines[0].confidence).toBe(0.96);
+    expect(typeof lines[0].latency_ms).toBe("number");
+    expect(typeof lines[0].ts).toBe("string");
+    // the key NEVER lands in the receipt
+    expect(JSON.stringify(lines[0])).not.toContain("k_test_");
+  });
+
+  it("a noul call receipts the primitive and the noul verdict; a choice confidence is absent", async () => {
+    const transport: JevTransport = async () => ({
+      status: 200,
+      text: async () => JSON.stringify({ model: "jev-1.13.0", answers: { thread: { type: "noul", noul: 0.71 } }, usage: { input_tokens: 300, output_tokens: 9 } }),
+    });
+
+    const res = await askJev({ thread: NOUL_QUESTION }, { title: "bug report" }, { sessionId: "ses_n", deps: { env: env(), transport } });
+    expect(res.ok).toBe(true);
+
+    const lines = receiptLines(w.receipts);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toMatchObject({ primitive: "noul", session_id: "ses_n" });
+    expect(lines[0].verdicts).toEqual([{ id: "thread", noul: 0.71 }]);
+    expect(lines[0]).not.toHaveProperty("confidence");
+  });
+
+  it("a FAILED call still receipts (no silent Jev branch) — error recorded, verdicts absent", async () => {
+    const transport: JevTransport = async () => ({ status: 503, text: async () => "unavailable" });
+
+    const res = await askJev({ junk_bucket: CHOICE_QUESTION }, { title: "hello" }, { deps: { env: env(), transport } });
+    expect(res.ok).toBe(false);
+
+    const lines = receiptLines(w.receipts);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toMatchObject({ kind: "jev-decision", primitive: "choice", model: null, error: expect.stringContaining("503") });
+    expect(lines[0]).not.toHaveProperty("verdicts");
+  });
+
+  it("no key → NO call, NO receipt (unavailability is the fail-open path, not a decision)", async () => {
+    const calls: number[] = [];
+    const transport: JevTransport = async () => {
+      calls.push(1);
+      return { status: 200, text: async () => "{}" };
+    };
+
+    const res = await askJev({ junk_bucket: CHOICE_QUESTION }, {}, { deps: { env: { AMICO_TYPESAFE_KEY_FILE: join(w.root, "missing-key"), AMICO_TYPESAFE_RECEIPTS: w.receipts }, transport } });
+
+    expect(res.ok).toBe(false);
+    if (res.ok) return;
+    expect(res.reason).toBe("key-missing");
+    expect(calls).toHaveLength(0);
+    expect(existsSync(w.receipts)).toBe(false);
+  });
+
+  it("the off-switch (AMICO_JEV_DISABLED) disables the path BEFORE the key read — zero calls, zero receipts", async () => {
+    const calls: number[] = [];
+    const transport: JevTransport = async () => {
+      calls.push(1);
+      return { status: 200, text: async () => "{}" };
+    };
+
+    const res = await askJev({ junk_bucket: CHOICE_QUESTION }, {}, { deps: { env: { AMICO_JEV_DISABLED: "1", AMICO_TYPESAFE_KEY_FILE: w.key, AMICO_TYPESAFE_RECEIPTS: w.receipts }, transport } });
+
+    expect(res).toMatchObject({ ok: false, reason: "disabled" });
+    expect(calls).toHaveLength(0);
+    expect(existsSync(w.receipts)).toBe(false);
+  });
+
+  it("a transport crash and a malformed body are {ok:false} (fail-open), each with its receipt", async () => {
+    const crash: JevTransport = async () => {
+      throw new Error("socket hang up");
+    };
+    expect(await askJev({ thread: NOUL_QUESTION }, {}, { deps: { env: env(), transport: crash } })).toMatchObject({ ok: false, reason: "transport" });
+
+    const garbage: JevTransport = async () => ({ status: 200, text: async () => "not json" });
+    expect(await askJev({ thread: NOUL_QUESTION }, {}, { deps: { env: env(), transport: garbage } })).toMatchObject({ ok: false, reason: "malformed" });
+
+    const lines = receiptLines(w.receipts);
+    expect(lines).toHaveLength(2);
+    expect(lines.every((l) => l.error !== undefined)).toBe(true);
+    // the key never leaks into error strings either
+    expect(JSON.stringify(lines)).not.toContain("k_test_");
+  });
+});
diff --git a/packages/amico-run/test/jev_curation.test.ts b/packages/amico-run/test/jev_curation.test.ts
new file mode 100644
index 00000000..a2f8b74a
--- /dev/null
+++ b/packages/amico-run/test/jev_curation.test.ts
@@ -0,0 +1,246 @@
+// jev_curation — issue #1311 (slice of #1301 session curation): the two
+// confidence-gated call sites on top of the jev_client — (a) the classifier
+// residual (sessions the deterministic rules leave unclassified get ONE
+// Jev Choice over the closed junk-bucket set; junk-bucket p ≥ 0.95 AND
+// age ≥ 48 h admits to the archive path) and (b) the onset thread-Noul
+// (one Noul per digest candidate; ≥ 0.5 promotes into the open-thread
+// surface — the digest itself stays deterministic).
+//
+// Thresholds are the curation spec's calibrated pair (spec-20260920-
+// session-curation §Calibration — "never act on an ambiguous mid-confidence
+// read"), named exports like the #1303 classifier's. Pure gates + question
+// builders; the loops are injectable-deps (transport stubbed — no network).
+// Run: `pnpm --filter @amicode/amico-run test`.
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  JEV_ARCHIVE_CONFIDENCE_MIN,
+  JEV_ARCHIVE_MIN_AGE_HOURS,
+  JUNK_BUCKET_RUBRIC,
+  jevArchiveAdmits,
+  jevJunkResidual,
+  jevThreadNouls,
+  junkResidualQuestion,
+  threadNoulQuestion,
+  type NoulCandidate,
+  type ResidualSession,
+  type SessionFeaturesLite,
+} from "../src/jev_curation.js";
+
+function features(over: Partial<SessionFeaturesLite> = {}): SessionFeaturesLite {
+  return {
+    title: "CZ gate design",
+    user_message_count: 6,
+    user_text_chars: 412,
+    assistant_message_count: 14,
+    todo_count: 0,
+    ...over,
+  };
+}
+
+// ── the closed bucket set + the no-match option (the issue's AC 2) ────────────
+describe("JUNK_BUCKET_RUBRIC — one rubric line per option, closed set + no-match", () => {
+  it("covers every classifier bucket AND the unclassified no-match option", () => {
+    expect(Object.keys(JUNK_BUCKET_RUBRIC).sort()).toEqual(["dead-cast", "junk-greeting", "probe", "substantive", "unclassified"]);
+  });
+
+  it("gives every option a non-empty rubric description", () => {
+    for (const [option, rubric] of Object.entries(JUNK_BUCKET_RUBRIC)) {
+      expect(rubric.length, option).toBeGreaterThan(10);
+    }
+  });
+});
+
+// ── the residual question: a deterministic fold + the choice shape ───────────
+describe("junkResidualQuestion — the state fold and the choice question", () => {
+  it("builds ONE choice question over the closed set; state is the deterministic fold (no raw text)", () => {
+    const { question, state } = junkResidualQuestion(features({ title: "hello", user_text_chars: 12, assistant_message_count: 3 }));
+    expect(question.type).toBe("choice");
+    expect(question.criteria).toBe(JUNK_BUCKET_RUBRIC);
+    expect(question.instructions.length).toBeGreaterThan(10);
+    expect(state).toEqual({
+      title: "hello",
+      user_message_count: 6,
+      user_text_chars: 12,
+      assistant_message_count: 3,
+      todo_count: 0,
+    });
+    // the fold carries counts and the title only — never message text
+    expect(JSON.stringify(state).length).toBeLessThan(400);
+  });
+});
+
+// ── the archive admission gate: p ≥ 0.95 AND age ≥ 48 h, never an ambiguous read ──
+describe("jevArchiveAdmits — the calibrated pair", () => {
+  it("exports the spec's thresholds as named constants", () => {
+    expect(JEV_ARCHIVE_CONFIDENCE_MIN).toBe(0.95);
+    expect(JEV_ARCHIVE_MIN_AGE_HOURS).toBe(48);
+  });
+
+  it("admits a junk-bucket read at p ≥ 0.95 AND age ≥ 48 h (boundaries inclusive)", () => {
+    expect(jevArchiveAdmits("junk-greeting", 0.95, 48)).toBe(true);
+    expect(jevArchiveAdmits("dead-cast", 0.99, 100)).toBe(true);
+    expect(jevArchiveAdmits("probe", 1.0, 72)).toBe(true);
+  });
+
+  it("never admits below the confidence floor — 0.94 is an ambiguous read", () => {
+    expect(jevArchiveAdmits("junk-greeting", 0.94, 100)).toBe(false);
+    expect(jevArchiveAdmits("dead-cast", 0.75, 100)).toBe(false); // the fleet-smoke shape: never act on a 0.75
+  });
+
+  it("never admits a session younger than the fixed 48 h Jev age gate", () => {
+    expect(jevArchiveAdmits("junk-greeting", 0.99, 47)).toBe(false);
+    expect(jevArchiveAdmits("junk-greeting", 0.99, 0)).toBe(false);
+  });
+
+  it("never admits a substantive or no-match verdict — the label must be a JUNK bucket", () => {
+    expect(jevArchiveAdmits("substantive", 1.0, 100)).toBe(false);
+    expect(jevArchiveAdmits("unclassified", 1.0, 100)).toBe(false);
+  });
+
+  it("a missing verdict (call failed / no answer) admits nothing — fail-open", () => {
+    expect(jevArchiveAdmits(undefined, 0, 100)).toBe(false);
+  });
+});
+
+// ── the loops: one call per residual/candidate session, fail-open per session ──
+
+/** A hermetic world for the loop tests: temp key + temp receipts. */
+function loopWorld(): { root: string; env: Record<string, string>; receipts: string } {
+  const root = mkdtempSync(join(tmpdir(), "amico-jev-cur-"));
+  const key = join(root, "key");
+  writeFileSync(key, "k_test_cur", { mode: 0o600 });
+  const receipts = join(root, "receipts", "receipts.jsonl");
+  return { root, env: { AMICO_TYPESAFE_KEY_FILE: key, AMICO_TYPESAFE_RECEIPTS: receipts }, receipts };
+}
+
+function residualSession(id: string, over: Partial<SessionFeaturesLite> = {}, ageHours = 72): ResidualSession {
+  return { id, features: features(over), ageHours };
+}
+
+describe("jevJunkResidual — the classifier residual loop", () => {
+  it("makes exactly ONE choice call per residual session, in order, and returns per-session verdicts", async () => {
+    const w = loopWorld();
+    try {
+      const bodies: unknown[] = [];
+      const transport = async (_url: string, init: { body: string }) => {
+        bodies.push(JSON.parse(init.body));
+        const questionId = Object.keys(JSON.parse(init.body).questions)[0];
+        return {
+          status: 200,
+          text: async () => JSON.stringify({ model: "jev-1.13.0", answers: { [questionId]: { type: "choice", choice: "substantive", confidence: 1.0 } }, usage: { input_tokens: 500, output_tokens: 21 } }),
+        };
+      };
+
+      const res = await jevJunkResidual([residualSession("ses_a"), residualSession("ses_b", { title: "hello", user_text_chars: 12, assistant_message_count: 2 })], { env: w.env, transport });
+
+      expect(res.status).toBe("ran");
+      expect(res.verdicts.ses_a).toEqual({ choice: "substantive", confidence: 1.0 });
+      expect(res.verdicts.ses_b).toEqual({ choice: "substantive", confidence: 1.0 });
+      // exactly one call per session, one question per call, the residual question shape
+      expect(bodies).toHaveLength(2);
+      for (const b of bodies as { questions: Record<string, { type: string; criteria: unknown }> }[]) {
+        expect(Object.keys(b.questions)).toHaveLength(1);
+        expect(Object.values(b.questions)[0].type).toBe("choice");
+        expect(Object.values(b.questions)[0].criteria).toEqual(JUNK_BUCKET_RUBRIC);
+      }
+    } finally {
+      rmSync(w.root, { recursive: true, force: true });
+    }
+  });
+
+  it("a failing call for one session fails OPEN for that session only — the others still judge", async () => {
+    const w = loopWorld();
+    try {
+      let n = 0;
+      const transport = async () => {
+        n += 1;
+        if (n === 1) return { status: 200, text: async () => JSON.stringify({ model: "jev-1.13.0", answers: { junk_bucket: { type: "choice", choice: "junk-greeting", confidence: 0.97 } }, usage: { input_tokens: 1, output_tokens: 1 } }) };
+        return { status: 500, text: async () => "boom" };
+      };
+
+      const res = await jevJunkResidual([residualSession("ses_ok"), residualSession("ses_down")], { env: w.env, transport });
+
+      expect(res.verdicts.ses_ok).toEqual({ choice: "junk-greeting", confidence: 0.97 });
+      expect(res.verdicts.ses_down).toEqual({ error: expect.any(String) });
+      // the gate composes: only the healthy read can admit
+      expect(jevArchiveAdmits(res.verdicts.ses_ok.choice, res.verdicts.ses_ok.confidence ?? 0, 72)).toBe(true);
+      expect(jevArchiveAdmits(res.verdicts.ses_down.choice, res.verdicts.ses_down.confidence ?? 0, 72)).toBe(false);
+    } finally {
+      rmSync(w.root, { recursive: true, force: true });
+    }
+  });
+
+  it("no key → status unavailable, ZERO transport calls (the primary test configuration)", async () => {
+    const w = loopWorld();
+    rmSync(w.root, { recursive: true, force: true }); // key gone with the world
+    const calls: number[] = [];
+    const transport = async () => {
+      calls.push(1);
+      return { status: 200, text: async () => "{}" };
+    };
+
+    const res = await jevJunkResidual([residualSession("ses_a")], { env: { AMICO_TYPESAFE_KEY_FILE: "/nonexistent/key", AMICO_TYPESAFE_RECEIPTS: "/tmp/x.jsonl" }, transport });
+    expect(res.status).toBe("unavailable");
+    expect(res.verdicts).toEqual({});
+    expect(calls).toHaveLength(0);
+  });
+
+  it("off-switch → status disabled, zero calls, zero delta", async () => {
+    const calls: number[] = [];
+    const transport = async () => {
+      calls.push(1);
+      return { status: 200, text: async () => "{}" };
+    };
+    const res = await jevJunkResidual([residualSession("ses_a")], { env: { AMICO_JEV_DISABLED: "1" }, transport });
+    expect(res.status).toBe("disabled");
+    expect(calls).toHaveLength(0);
+  });
+});
+
+describe("jevThreadNouls — the onset digest's noul map", () => {
+  function candidate(id: string, over: Partial<NoulCandidate> = {}): NoulCandidate {
+    return { id, title: `Thread ${id}`, lastAssistantText: "Which solver should I pin?", pendingTodos: 1, ...over };
+  }
+
+  it("builds ONE noul question per candidate: true/false criteria, digest-sized state", () => {
+    const { question, state } = threadNoulQuestion(candidate("ses_x", { lastAssistantText: "Waiting on your call.".repeat(400) }));
+    expect(question.type).toBe("noul");
+    expect(question.criteria).toHaveProperty("true");
+    expect(question.criteria).toHaveProperty("false");
+    // the fold truncates the text — digests, never spines
+    expect(JSON.stringify(state).length).toBeLessThan(600);
+  });
+
+  it("makes ONE noul call per candidate and returns the map; failures fail open (session absent from the map)", async () => {
+    const w = loopWorld();
+    try {
+      let n = 0;
+      const transport = async (_url: string, init: { body: string }) => {
+        n += 1;
+        const questionId = Object.keys(JSON.parse(init.body).questions)[0];
+        if (n === 2) return { status: 503, text: async () => "down" };
+        return { status: 200, text: async () => JSON.stringify({ model: "jev-1.13.0", answers: { [questionId]: { type: "noul", noul: 0.71 } }, usage: { input_tokens: 300, output_tokens: 9 } }) };
+      };
+
+      const res = await jevThreadNouls([candidate("ses_a"), candidate("ses_b")], { env: w.env, transport });
+      expect(res.status).toBe("ran");
+      expect(res.nouls).toEqual({ ses_a: 0.71 }); // ses_b failed → absent, never a guessed 0
+    } finally {
+      rmSync(w.root, { recursive: true, force: true });
+    }
+  });
+
+  it("no key / off-switch → unavailable / disabled with an EMPTY map (the digest degrades to today)", async () => {
+    const transport = async () => ({ status: 200, text: async () => "{}" });
+    const off = await jevThreadNouls([candidate("ses_a")], { env: { AMICO_JEV_DISABLED: "1" }, transport });
+    expect(off.status).toBe("disabled");
+    expect(off.nouls).toEqual({});
+    const missing = await jevThreadNouls([candidate("ses_a")], { env: { AMICO_TYPESAFE_KEY_FILE: "/nonexistent" }, transport });
+    expect(missing.status).toBe("unavailable");
+    expect(missing.nouls).toEqual({});
+  });
+});
diff --git a/packages/amico-run/test/s31.test.ts b/packages/amico-run/test/s31.test.ts
index aef95462..f8a0c2c8 100644
--- a/packages/amico-run/test/s31.test.ts
+++ b/packages/amico-run/test/s31.test.ts
@@ -21,7 +21,14 @@ const FORBIDDEN = [/--gate\b/, /--system\b/, /--pulse\b/, /modelcontextprotocol/
 // callback server (node:http) + fetch for Slack's oauth.v2.access token
 // exchange and users.info name resolution. Same class of sanctioned edge as
 // the cloud client.
-const EXEMPT = new Set(["cloud_client.ts", "slack_verb.ts"]);
+//
+// jev_client.ts (#1311, slice of #1301 session curation): the ONE thin Jev
+// client (TypeSafe System One decision API) for the confidence-gated
+// curation middle layer — the amico-run doctrine's named home for that wire
+// ("one thin client per repo, amico-run package for amicode surfaces" —
+// spec-20260920-jev-integration). Fail-open by construction; every call
+// receipted; the transport is injectable so the suite stays hermetic.
+const EXEMPT = new Set(["cloud_client.ts", "slack_verb.ts", "jev_client.ts"]);
 
 describe("S31 grep rule", () => {
   it("src/ contains no forbidden tool-layer patterns", () => {
diff --git a/packages/amico-run/test/sessions_verb.test.ts b/packages/amico-run/test/sessions_verb.test.ts
index 38e3fca5..c19ff447 100644
--- a/packages/amico-run/test/sessions_verb.test.ts
+++ b/packages/amico-run/test/sessions_verb.test.ts
@@ -72,7 +72,10 @@ beforeAll(() => {
 
 function run(args: string[], env: Record<string, string> = {}): { code: number; stdout: string; stderr: string } {
   try {
-    const stdout = execFileSync("node", [BUNDLE, ...args], { encoding: "utf8", env: { ...process.env, ...env } });
+    // AMICO_JEV_DISABLED guards the bundle hermetically: the machine's real
+    // ~/.amico/typesafe/key would otherwise arm the live Jev residual inside
+    // autoarchive. Tests that WANT the enabled path override this explicitly.
+    const stdout = execFileSync("node", [BUNDLE, ...args], { encoding: "utf8", env: { ...process.env, AMICO_JEV_DISABLED: "1", ...env } });
     return { code: 0, stdout, stderr: "" };
   } catch (e) {
     const err = e as { status?: number; stdout?: string; stderr?: string };
@@ -96,6 +99,8 @@ interface SeedOpts {
   userMessages?: string[];
   /** Assistant message count (no parts — the classifier only counts turns). */
   assistantMessages?: number;
+  /** One assistant message with a text part carrying this text (#1311 thread-noul sweep). */
+  lastAssistantText?: string;
   /** Pending todo rows (status 'pending', the open-threads convention). */
   pendingTodos?: number;
 }
@@ -186,6 +191,12 @@ for s in seeds:
     for i in range(s.get("assistantMessages") or 0):
         con.execute("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?,?,?,?,?)",
                     ("msg_%s_a%d" % (s["id"], i), s["id"], created, updated, json.dumps({"role": "assistant"})))
+    if s.get("lastAssistantText") is not None:
+        mid = "msg_%s_last" % s["id"]
+        con.execute("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?,?,?,?,?)",
+                    (mid, s["id"], created, updated, json.dumps({"role": "assistant"})))
+        con.execute("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?,?,?,?,?,?)",
+                    ("part_" + mid, mid, s["id"], created, updated, json.dumps({"type": "text", "text": s["lastAssistantText"]})))
     for i in range(s.get("pendingTodos") or 0):
         con.execute("INSERT INTO todo (session_id, content, status, priority, position, time_created, time_updated) VALUES (?,?,?,?,?,?,?)",
                     (s["id"], "todo %d" % i, "pending", "medium", i, created, updated))
@@ -745,6 +756,9 @@ describe("ops/session-archive job — the nightly wrapper (smoke, #1304)", () =>
       SESSION_ARCHIVE_RECEIPTS: receipts,
       SESSION_ARCHIVE_AMICO: BUNDLE,
       AMICODE_OPS_DIR: ops,
+      // hermeticity: the nightly wrapper spawns the CLI; without this the
+      // machine's real jev key would arm the live residual inside autoarchive
+      AMICO_JEV_DISABLED: "1",
     };
   }
 
@@ -811,3 +825,274 @@ describe("ops/session-archive job — the nightly wrapper (smoke, #1304)", () =>
     expect(existsSync(receipts)).toBe(false);
   });
 });
+
+// ══ #1311: the Jev classifier residual in autoarchive (the middle layer) ═══
+// Residual-only wiring: sessions the deterministic rules leave unclassified
+// get ONE Jev Choice; junk-bucket p ≥ 0.95 AND the FIXED 48 h gate admit to
+// the archive path as an OR with the deterministic junk rule (which stays
+// first and untouched). In-process deps inject the jev pass (no network);
+// bundle runs prove the off-switch / unavailable zero-delta paths.
+import { sessionsAutoarchive } from "../src/sessions_verb.js";
+import { jevArchiveAdmits, type ResidualSession, type ResidualVerdict } from "../src/jev_curation.js";
+
+/** A fake jev pass for the in-process wiring tests: records the sessions it
+ * was asked about, answers from the given verdict map. */
+function fakeJev(verdicts: Record<string, ResidualVerdict>, log: ResidualSession[] = []) {
+  return async (sessions: ResidualSession[]): Promise<{ status: "ran"; verdicts: Record<string, ResidualVerdict> }> => {
+    log.push(...sessions);
+    return { status: "ran", verdicts };
+  };
+}
+
+describe("sessions autoarchive — the jev classifier residual (#1311, in-process)", () => {
+  let tmp: string;
+  let db: string;
+  let ops: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "amico-jev-res-"));
+    db = join(tmp, "opencode.db");
+    ops = join(tmp, "ops");
+    mkdirSync(ops, { recursive: true });
+  });
+  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+  it("RESIDUAL-ONLY: the deterministic junk sessions get NO jev call — only the rule-unclassified do", async () => {
+    seedDb(db, junkSeeds());
+    const asked: ResidualSession[] = [];
+
+    const r = await sessionsAutoarchive(["--db", db], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops }, { jev: fakeJev({}, asked) });
+
+    expect(r.code).toBe(0);
+    // the three junk sessions never reach the middle layer; ses_real (substantive, 72 h) is the residual
+    expect(asked.map((s) => s.id)).toEqual(["ses_real"]);
+    expect(asked[0].ageHours).toBeGreaterThanOrEqual(48);
+  });
+
+  it("admits a junk-bucket read at p ≥ 0.95 AND age ≥ 48 h: the session archives with the deterministic junk", async () => {
+    seedDb(db, [
+      ...junkSeeds(),
+      { id: "ses_ambiguous", title: "Untitled follow-up", userMessages: ["hi"], assistantMessages: 2, updatedHoursAgo: 49 },
+    ]);
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops };
+
+    const dry = (await sessionsAutoarchive(["--db", db], env, { jev: fakeJev({ ses_ambiguous: { choice: "junk-greeting", confidence: 0.96 } }) })).json as Record<string, unknown>;
+    expect(dry.candidates).toBe(4);
+    expect(dry.jev).toMatchObject({ status: "ran", consulted: 2, admitted: 1, admitted_ids: ["ses_ambiguous"] });
+
+    const applied = (await sessionsAutoarchive(["--db", db, "--apply"], env, { jev: fakeJev({ ses_ambiguous: { choice: "junk-greeting", confidence: 0.96 } }) })).json as Record<string, unknown>;
+    expect(applied.archived).toBe(4);
+    const visible = JSON.parse(run(["sessions", "list"], env).stdout);
+    expect((visible.sessions as { id: string }[]).map((s) => s.id).sort()).toEqual(["ses_real", "ses_young"].sort());
+  });
+
+  it("the calibrated pair holds at the boundary: 0.94 never admits; 'substantive' and 'unclassified' never admit", async () => {
+    seedDb(db, [
+      { id: "ses_a", title: "Untitled one", userMessages: ["hi"], assistantMessages: 2, updatedHoursAgo: 49 },
+      { id: "ses_b", title: "Untitled two", userMessages: ["hi"], assistantMessages: 2, updatedHoursAgo: 49 },
+      { id: "ses_c", title: "Untitled three", userMessages: ["hi"], assistantMessages: 2, updatedHoursAgo: 49 },
+    ]);
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops };
+    const verdicts: Record<string, ResidualVerdict> = {
+      ses_a: { choice: "junk-greeting", confidence: 0.94 },
+      ses_b: { choice: "substantive", confidence: 1.0 },
+      ses_c: { choice: "unclassified", confidence: 1.0 },
+    };
+
+    const r = (await sessionsAutoarchive(["--db", db], env, { jev: fakeJev(verdicts) })).json as Record<string, unknown>;
+    expect(r.candidates).toBe(0);
+    expect(r.jev).toMatchObject({ consulted: 3, admitted: 0 });
+  });
+
+  it("the jev age gate is the FIXED 48 h, never the scan cutoff: a fresh scanned session is untouchable on a model's word", async () => {
+    seedDb(db, [
+      { id: "ses_fresh_sub", title: "Untitled fresh", userMessages: ["just started this"], assistantMessages: 2, updatedHoursAgo: 2 },
+    ]);
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops };
+
+    // --hours 1 scans the 2 h-old session; jev reads junk at 0.99 — still NO admission (2 h < 48 h)
+    const r = (await sessionsAutoarchive(["--db", db, "--hours", "1"], env, { jev: fakeJev({ ses_fresh_sub: { choice: "junk-greeting", confidence: 0.99 } }) })).json as Record<string, unknown>;
+    expect(r.candidates).toBe(0);
+    expect(r.jev).toMatchObject({ admitted: 0 });
+  });
+
+  it("fail-open: a crashing jev pass never breaks the archive run — deterministic candidates survive intact", async () => {
+    seedDb(db, junkSeeds());
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops };
+    const crash = async () => {
+      throw new Error("jev down");
+    };
+
+    const dry = (await sessionsAutoarchive(["--db", db], env, { jev: crash })).json as Record<string, unknown>;
+    expect(dry.candidates).toBe(3); // the deterministic junk, untouched
+    expect(dry.jev).toMatchObject({ status: "error" });
+    expect(run(["sessions", "list"], env).code).toBe(0);
+  });
+});
+
+describe("sessions autoarchive — the jev off-switch and unavailability (bundle)", () => {
+  let tmp: string;
+  let db: string;
+  let ops: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "amico-jev-off-"));
+    db = join(tmp, "opencode.db");
+    ops = join(tmp, "ops");
+    mkdirSync(ops, { recursive: true });
+  });
+  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+  /** The deterministic output's exact key set — the zero-delta contract. */
+  const DETERMINISTIC_KEYS = [
+    "archived",
+    "buckets",
+    "candidate_ids",
+    "candidates",
+    "cutoff_iso",
+    "cutoff_ms",
+    "dry_run",
+    "hours",
+    "note",
+    "scanned",
+    "subcommand",
+    "verb",
+  ].sort();
+
+  it("AMICO_JEV_DISABLED=1 → ZERO delta: the output JSON is exactly the deterministic shape (no jev key)", () => {
+    seedDb(db, junkSeeds());
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops, AMICO_JEV_DISABLED: "1" };
+    const r = JSON.parse(run(["sessions", "autoarchive"], env).stdout);
+    expect(Object.keys(r).sort()).toEqual(DETERMINISTIC_KEYS);
+    expect(r.candidates).toBe(3);
+  });
+
+  it("enabled but no key → fail-open with the honest unavailable report; the deterministic path is untouched", () => {
+    seedDb(db, junkSeeds());
+    const env = {
+      OPENCODE_DB: db,
+      AMICODE_OPS_DIR: ops,
+      AMICO_JEV_DISABLED: "0",
+      AMICO_TYPESAFE_KEY_FILE: join(tmp, "missing-key"),
+    };
+    const r = JSON.parse(run(["sessions", "autoarchive"], env).stdout);
+    expect(r.candidates).toBe(3);
+    expect(new Set(r.candidate_ids as string[])).toEqual(new Set(JUNK_OLD_IDS));
+    expect(r.jev).toMatchObject({ status: "unavailable" });
+  });
+
+  it("default harness runs carry no jev key either (hermeticity guard, machine-key-proof)", () => {
+    seedDb(db, junkSeeds());
+    // run() injects AMICO_JEV_DISABLED=1 — the machine's real key cannot arm the residual
+    const r = JSON.parse(run(["sessions", "autoarchive"], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops }).stdout);
+    expect(r.jev).toBeUndefined();
+  });
+});
+
+// ══ #1311: the onset thread-Noul pass — the amico-run half of the digest seam ══
+// `amico sessions thread-noul` sweeps the digest window, ONE noul call per
+// candidate (junk titles pre-filtered deterministically), and writes the
+// derived map the onset digest reads (thread-nouls.json in the ops dir —
+// dry-run by default, --apply writes). Fail-open on every client failure.
+import { sessionsThreadNoul } from "../src/sessions_verb.js";
+import type { NoulCandidate } from "../src/jev_curation.js";
+
+describe("amico sessions thread-noul — the derived noul map (#1311, in-process)", () => {
+  let tmp: string;
+  let db: string;
+  let ops: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "amico-jev-noul-"));
+    db = join(tmp, "opencode.db");
+    ops = join(tmp, "ops");
+    mkdirSync(ops, { recursive: true });
+  });
+  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+  function fakeNouls(nouls: Record<string, number>, log: NoulCandidate[] = []) {
+    return async (candidates: NoulCandidate[]) => {
+      log.push(...candidates);
+      return { status: "ran" as const, nouls };
+    };
+  }
+
+  it("sweeps the window and asks ONE noul per NON-JUNK candidate — junk titles pre-filtered, window honored", async () => {
+    seedDb(db, [
+      { id: "ses_bug", title: "Bug report: panel", userMessages: ["the panel loses sessions"], lastAssistantText: "The fix is staged — waiting on your confirmation.", pendingTodos: 1, updatedHoursAgo: 20 },
+      { id: "ses_greeting", title: "hello", userMessages: ["hi"], lastAssistantText: "Hello!", updatedHoursAgo: 2 },
+      { id: "ses_old", title: "Ancient work", userMessages: ["old"], lastAssistantText: "done", createdDaysAgo: 40, updatedDaysAgo: 39 },
+    ]);
+    const asked: NoulCandidate[] = [];
+
+    const r = (await sessionsThreadNoul(["--db", db], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops }, { jev: fakeNouls({ ses_bug: 0.71 }, asked) })).json as Record<string, unknown>;
+
+    // only the bug report: greeting junk pre-filtered, the 39-day-old session outside the 14-day window
+    expect(asked.map((c) => c.id)).toEqual(["ses_bug"]);
+    expect(asked[0]).toMatchObject({ title: "Bug report: panel", pendingTodos: 1 });
+    expect(asked[0].lastAssistantText).toContain("waiting on your confirmation");
+    expect(r).toMatchObject({ subcommand: "thread-noul", status: "ran", candidates: 1, judged: 1 });
+  });
+
+  it("dry-run is the DEFAULT (reports, writes no map); --apply writes the map the digest reads", async () => {
+    seedDb(db, [
+      { id: "ses_bug", title: "Bug report: panel", userMessages: ["fix it"], lastAssistantText: "Waiting on your call.", pendingTodos: 1, updatedHoursAgo: 20 },
+    ]);
+    const env = { OPENCODE_DB: db, AMICODE_OPS_DIR: ops };
+    const mapPath = join(ops, "thread-nouls.json");
+
+    const dry = (await sessionsThreadNoul(["--db", db], env, { jev: fakeNouls({ ses_bug: 0.71 }) })).json as Record<string, unknown>;
+    expect(dry.dry_run).toBe(true);
+    expect(existsSync(mapPath)).toBe(false);
+
+    const applied = (await sessionsThreadNoul(["--db", db, "--apply"], env, { jev: fakeNouls({ ses_bug: 0.71 }) })).json as Record<string, unknown>;
+    expect(applied.dry_run).toBe(false);
+    expect(applied.map_path).toBe(mapPath);
+    const written = JSON.parse(readFileSync(mapPath, "utf8"));
+    expect(written).toMatchObject({ schema_version: 1, entries: { ses_bug: 0.71 } });
+    expect(typeof written.generated_at).toBe("string");
+  });
+
+  it("fail-open: a crashing pass reports the error, writes NO map, exits 0", async () => {
+    seedDb(db, [
+      { id: "ses_bug", title: "Bug report: panel", userMessages: ["fix it"], lastAssistantText: "Waiting on your call.", updatedHoursAgo: 20 },
+    ]);
+    const crash = async () => {
+      throw new Error("jev down");
+    };
+
+    const r = (await sessionsThreadNoul(["--db", db, "--apply"], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops }, { jev: crash })).json as Record<string, unknown>;
+    expect(r.status).toBe("error");
+    expect(existsSync(join(ops, "thread-nouls.json"))).toBe(false);
+  });
+
+  it("no key → unavailable, no map (the fail-open configuration)", async () => {
+    seedDb(db, [
+      { id: "ses_bug", title: "Bug report: panel", userMessages: ["fix it"], lastAssistantText: "Waiting on your call.", updatedHoursAgo: 20 },
+    ]);
+    const jev = async (candidates: NoulCandidate[]) => ({ status: "unavailable" as const, nouls: {} as Record<string, number> });
+
+    const r = (await sessionsThreadNoul(["--db", db, "--apply"], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops, AMICO_TYPESAFE_KEY_FILE: join(tmp, "missing-key") }, { jev })).json as Record<string, unknown>;
+    expect(r.status).toBe("unavailable");
+    expect(r.candidates).toBe(1);
+    expect(r).not.toHaveProperty("entries");
+    expect(existsSync(join(ops, "thread-nouls.json"))).toBe(false);
+  });
+
+  it("the off-switch (bundle): ZERO delta — no jev block, no map, exit 0", () => {
+    seedDb(db, [
+      { id: "ses_bug", title: "Bug report: panel", userMessages: ["fix it"], lastAssistantText: "Waiting on your call.", updatedHoursAgo: 20 },
+    ]);
+    const r = JSON.parse(run(["sessions", "thread-noul", "--apply"], { OPENCODE_DB: db, AMICODE_OPS_DIR: ops }).stdout);
+    expect(r.verb).toBe("sessions");
+    expect(r.subcommand).toBe("thread-noul"); // the verb RAN (not a usage error)
+    expect(r.jev).toBeUndefined();
+    expect(r.status).toBeUndefined();
+    expect(existsSync(join(ops, "thread-nouls.json"))).toBe(false);
+  });
+
+  it("usage: a missing DB is an honest 64; bad --days is a usage error", async () => {
+    expect((await sessionsThreadNoul(["--db", join(tmp, "nope.db")], { AMICODE_OPS_DIR: ops })).code).toBe(64);
+    expect((await sessionsThreadNoul(["--db", db, "--days", "0"], { AMICODE_OPS_DIR: ops })).code).toBe(64);
+  });
+});
diff --git a/packages/amico-run/test/slow/jev_calibration.test.ts b/packages/amico-run/test/slow/jev_calibration.test.ts
new file mode 100644
index 00000000..c4cae5ed
--- /dev/null
+++ b/packages/amico-run/test/slow/jev_calibration.test.ts
@@ -0,0 +1,39 @@
+// jev_calibration (LIVE) — issue #1311: the on-demand calibration harness.
+// Replays the hand-labeled 2026-09-20 sweep set through the REAL Jev client
+// (one choice + one noul per session) and grades today's answers: bucket
+// agreement, action agreement, noul spread, Brier per primitive — ONE JSON
+// object on stdout.
+//
+// RUN-ON-DEMAND (network + the server-side key; NEVER part of the unit suite
+// — the fast suite excludes **/slow/** and this self-gates on the opt-in env):
+//
+//   AMICO_TEST_JEV_CALIBRATION=1 pnpm --filter @amicode/amico-run run test:slow
+//
+// The key resolves through the standard posture ($AMICO_TYPESAFE_KEY_FILE →
+// ~/.amico/typesafe/key); receipts land in the shared curation journal.
+// Re-run whenever the model version moves (the version rides every receipt).
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { runCalibrationBattery, type CalibrationEntry } from "../../src/jev_calibration.js";
+
+const entries = (
+  JSON.parse(readFileSync(join(__dirname, "..", "fixtures", "jev", "calibration-2026-09-20.json"), "utf8")) as {
+    entries: CalibrationEntry[];
+  }
+).entries;
+
+describe.skipIf(!process.env.AMICO_TEST_JEV_CALIBRATION)("slow: the LIVE jev calibration battery (network, opt-in)", () => {
+  it("replays the 2026-09-20 sweep set live and prints the graded battery as JSON", async () => {
+    const battery = await runCalibrationBattery(entries);
+
+    // ONE JSON object out — the harness output contract
+    console.log(JSON.stringify(battery));
+
+    // the battery must grade something to be a battery
+    expect(battery.status).toBe("ran");
+    expect(battery.choice.judged).toBeGreaterThan(0);
+    expect(battery.noul.judged).toBeGreaterThan(0);
+  });
+});
diff --git a/packages/extension/opencode-plugin/amicode_context.ts b/packages/extension/opencode-plugin/amicode_context.ts
index af5f33fc..6f432440 100644
--- a/packages/extension/opencode-plugin/amicode_context.ts
+++ b/packages/extension/opencode-plugin/amicode_context.ts
@@ -26,7 +26,7 @@
 import { buildModeBlock, deployedModesRoot, type ModeBlockClient } from "./mode_block";
 import { buildStackStateBlock } from "./stack_state";
 import { buildRecentSessionsBlock } from "./session_recap";
-import { buildOpenThreadsBlock } from "./open_threads";
+import { buildOpenThreadsBlock, readThreadNoulMap } from "./open_threads";
 import { buildSetupStateSection } from "./setup_state";
 import { applyHarmoniqsHeaders } from "./harmoniqs_transport";
 
@@ -98,9 +98,15 @@ export const AmicodeContext = async (input: unknown) => {
 
       // Open-threads digest (#1305) — derived, deterministic read of what is
       // still open, rendered after the recent-sessions block. PR-state is an
-      // input feature; this pass spends no network call.
+      // input feature; this pass spends no network call. The #1311 thread-Noul
+      // map is the same shape of input: the amico-run curation pass spent the
+      // Jev calls and wrote the derived map; this hook only READS it (ranking
+      // + ≥ 0.5 promotion — bucket labels stay deterministic, and an absent
+      // map degrades the digest to #1305's exact behavior).
       try {
-        const threadsBlock = buildOpenThreadsBlock(input.sessionID);
+        const threadNouls = readThreadNoulMap();
+        const threadNoulFor = threadNouls === undefined ? undefined : (sessionId: string) => threadNouls[sessionId];
+        const threadsBlock = buildOpenThreadsBlock(input.sessionID, undefined, threadNoulFor);
         if (threadsBlock) {
           output.system.push(threadsBlock);
         }
diff --git a/packages/extension/opencode-plugin/open_threads.ts b/packages/extension/opencode-plugin/open_threads.ts
index d3ebc4f7..0961299e 100644
--- a/packages/extension/opencode-plugin/open_threads.ts
+++ b/packages/extension/opencode-plugin/open_threads.ts
@@ -69,6 +69,9 @@ export interface OpenThread {
   signal: string;
   created: string; // ISO
   ageDays: number;
+  /** The thread-Noul (#1311) — an INPUT feature from the derived map the
+   *  amico-run pass writes; undefined = no map entry = today's digest. */
+  threadNoul?: number;
 }
 
 // ── Configuration (defaults + env seams) ─────────────────────────────────────
@@ -233,26 +236,44 @@ export function buildThread(
 
 // ── Digest composition (pure, testable) ──────────────────────────────────────
 
+/** The thread-Noul promotion gate (#1311) — the curation spec's calibrated
+ * pair (spec-20260920-session-curation §Calibration): a noul ≥ 0.5 promotes a
+ * session into the open-thread surface (ranking + cap); below it is today's
+ * behavior. Jev never derives a bucket label — promotion only. */
+export const THREAD_NOUL_PROMOTION_MIN = 0.5;
+
+const isPromoted = (t: OpenThread): boolean => t.threadNoul !== undefined && t.threadNoul >= THREAD_NOUL_PROMOTION_MIN;
+
 /**
- * Compose the markdown block. Ordering: non-stale threads newest-first
- * (recency wins ties — input order preserved), stale threads last (also
- * newest-first, flagged). Capped at `maxThreads`. Returns null when there
- * are no open threads — the honest empty state, no filler.
+ * Compose the markdown block. Ordering (#1305, unchanged when no nouls):
+ * non-stale threads newest-first (recency wins ties — input order preserved),
+ * stale threads last (also newest-first, flagged). Capped at `maxThreads`.
+ *
+ * The #1311 thread-Noul rides as an INPUT feature: promoted threads (noul ≥
+ * 0.5) rank ahead within their staleness group, BY NOUL DESC (Jev ranks the
+ * surface), and win cap slots over mere recency — promotion INTO the
+ * surface. A sub-threshold noul neither promotes nor drops (fail-open: no
+ * Jev read ever removes a deterministically-surfaced thread). With no nouls
+ * at all the ordering is exactly #1305's. Returns null when there are no
+ * open threads — the honest empty state, no filler.
  */
 export function composeOpenThreadsDigest(threads: OpenThread[], maxThreads: number): string | null {
   if (threads.length === 0) return null;
 
   const byAge = (a: OpenThread, b: OpenThread): number => a.ageDays - b.ageDays;
+  const byNoulDesc = (a: OpenThread, b: OpenThread): number => (b.threadNoul ?? 0) - (a.threadNoul ?? 0) || byAge(a, b);
   const ordered = [
-    ...threads.filter(t => t.bucket !== "stale").sort(byAge),
-    ...threads.filter(t => t.bucket === "stale").sort(byAge),
+    ...threads.filter(t => t.bucket !== "stale" && isPromoted(t)).sort(byNoulDesc),
+    ...threads.filter(t => t.bucket !== "stale" && !isPromoted(t)).sort(byAge),
+    ...threads.filter(t => t.bucket === "stale" && isPromoted(t)).sort(byNoulDesc),
+    ...threads.filter(t => t.bucket === "stale" && !isPromoted(t)).sort(byAge),
   ].slice(0, maxThreads);
 
   const lines = ["## Open threads", ""];
   for (const t of ordered) {
     const date = new Date(t.created);
     const dateStr = date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
-    lines.push(`- **${t.bucket}** — ${dateStr} — ${t.title} — ${t.signal}`);
+    lines.push(`- **${t.bucket}** — ${dateStr} — ${t.title} — ${t.signal}${t.threadNoul !== undefined ? ` · noul ${t.threadNoul.toFixed(2)}` : ""}`);
   }
   return lines.join("\n");
 }
@@ -306,16 +327,46 @@ function queryPendingTodos(db: any, sessionId: string): number {
 
 // ── Public API ───────────────────────────────────────────────────────────────
 
+/** The derived thread-Noul map's home (#1311): the amico-run curation pass
+ *  (`amico sessions thread-noul`) writes it into the ops dir; the digest
+ *  READS it (input feature — this module still makes no network call).
+ *  $AMICODE_OPS_DIR → ~/.amico/amicode (the setup-state seam). */
+export function threadNoulMapFile(opsDir?: string): string {
+  const dir = opsDir ?? process.env.AMICODE_OPS_DIR ?? path.join(os.homedir(), ".amico", "amicode");
+  return path.join(dir, "thread-nouls.json");
+}
+
+/** Read the derived noul map — Record<session_id, noul>, or undefined when
+ *  the map is absent/corrupt (fail-open: the digest degrades to today). */
+export function readThreadNoulMap(mapPath?: string): Record<string, number> | undefined {
+  const resolved = mapPath ?? threadNoulMapFile();
+  if (!fs.existsSync(resolved)) return undefined;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(resolved, "utf8")) as { entries?: Record<string, unknown> };
+    if (parsed.entries === undefined || typeof parsed.entries !== "object") return undefined;
+    const out: Record<string, number> = {};
+    for (const [id, n] of Object.entries(parsed.entries)) {
+      if (typeof n === "number" && Number.isFinite(n)) out[id] = n;
+    }
+    return out;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Sweep recent sessions, classify open threads, compose the digest block.
  * `prStateFor` injects PR-state as an INPUT feature map per session — the
  * caller decides when to spend a network call; this module never fetches.
- * Returns null when there are no open threads, the DB is unavailable (e.g.
- * under Node/vitest), or on error.
+ * `threadNoulFor` (#1311) is the same seam for the derived thread-Noul map
+ * (the amico-run pass spends the Jev calls; ranking + ≥ 0.5 promotion ride
+ * the map, bucket labels stay deterministic). Returns null when there are
+ * no open threads, the DB is unavailable (e.g. under Node/vitest), or on error.
  */
 export function buildOpenThreadsBlock(
   currentSessionId?: string,
   prStateFor?: (sessionId: string) => PrState | undefined,
+  threadNoulFor?: (sessionId: string) => number | undefined,
 ): string | null {
   if (!SqliteDatabase) return null;
 
@@ -367,7 +418,11 @@ export function buildOpenThreadsBlock(
         },
         staleAfterDays,
       );
-      if (thread) threads.push(thread);
+      if (thread) {
+        const noul = threadNoulFor?.(s.id);
+        if (noul !== undefined) thread.threadNoul = noul;
+        threads.push(thread);
+      }
     }
 
     return composeOpenThreadsDigest(threads, maxThreads);
diff --git a/packages/extension/test/open_threads.test.ts b/packages/extension/test/open_threads.test.ts
index 15bcbc3f..da4b73cc 100644
--- a/packages/extension/test/open_threads.test.ts
+++ b/packages/extension/test/open_threads.test.ts
@@ -19,10 +19,12 @@ import {
   buildThread,
   composeOpenThreadsDigest,
   buildOpenThreadsBlock,
+  readThreadNoulMap,
   resolveWindowDays,
   resolveMaxThreads,
   resolveStaleDays,
   JUNK_TITLE_WORDS,
+  THREAD_NOUL_PROMOTION_MIN,
   DEFAULT_WINDOW_DAYS,
   DEFAULT_MAX_THREADS,
   DEFAULT_STALE_DAYS,
@@ -348,8 +350,141 @@ describe("amicode_context wiring — open-threads block follows the recap block"
 
   it("pushes the open-threads block after the recent-sessions block", () => {
     const recapAt = source.indexOf("buildRecentSessionsBlock(input.sessionID)");
-    const threadsAt = source.indexOf("buildOpenThreadsBlock(input.sessionID)");
+    const threadsAt = source.indexOf("buildOpenThreadsBlock(input.sessionID");
     expect(recapAt).toBeGreaterThan(-1);
     expect(threadsAt).toBeGreaterThan(recapAt);
   });
 });
+
+// ── #1311: the thread-Noul middle layer — ranking + promotion, labels stay deterministic ──
+// The noul map is an INPUT feature (sibling of prStateFor: the amico-run pass
+// spends the network; this module reads a derived map). Jev informs ranking
+// and promotion ONLY — the bucket label and the no-noul ordering are exactly
+// #1305's, so an absent map degrades to today's digest byte-for-byte.
+
+describe("thread-Noul promotion — ranking + cap (#1311)", () => {
+  function mk(overrides: Partial<OpenThread> = {}): OpenThread {
+    return {
+      session_id: "ses_x",
+      title: "Thread",
+      bucket: "parked",
+      signal: "2 pending todos",
+      created: "2026-09-18T10:00:00.000Z",
+      ageDays: 2,
+      ...overrides,
+    };
+  }
+
+  it("exports the promotion threshold as a named constant (the curation spec's calibrated gate)", () => {
+    expect(THREAD_NOUL_PROMOTION_MIN).toBe(0.5);
+  });
+
+  it("ZERO-DELTA: threads with no noul compose to exactly today's digest (no noul rendered, today's order)", () => {
+    const threads = [
+      mk({ session_id: "a", title: "Old fresh", ageDays: 6 }),
+      mk({ session_id: "b", title: "New fresh", ageDays: 1 }),
+      mk({ session_id: "c", title: "Stale one", bucket: "stale", ageDays: 21 }),
+    ];
+    const md = composeOpenThreadsDigest(threads, 5)!;
+    expect(md).not.toContain("noul");
+    const pos = (t: string) => md.indexOf(t);
+    expect(pos("New fresh")).toBeLessThan(pos("Old fresh"));
+    expect(pos("Old fresh")).toBeLessThan(pos("Stale one"));
+  });
+
+  it("PROMOTES: a noul ≥ 0.5 outranks recency under the cap — a capped-out thread makes the surface", () => {
+    const threads = Array.from({ length: 8 }, (_, i) =>
+      mk({ session_id: `t${i}`, title: `Thread ${i}`, ageDays: i + 1 }),
+    );
+    // threads 6 and 7 would lose the cap of 3 to recency — the noul promotes them in
+    threads[6].threadNoul = 0.6;
+    threads[7].threadNoul = 0.91;
+    const md = composeOpenThreadsDigest(threads, 3)!;
+    // promoted first, BY NOUL DESC (Jev ranks the surface), then today's order fills
+    const pos = (t: string) => md.indexOf(t);
+    expect(pos("Thread 7")).toBeLessThan(pos("Thread 6"));
+    expect(md).toContain("Thread 0"); // the rest, today's recency order, fills the cap
+    expect(md).not.toContain("Thread 2");
+  });
+
+  it("the digest CARRIES the noul per surfaced session (rendered on the line)", () => {
+    const md = composeOpenThreadsDigest(
+      [mk({ title: "Bug report", bucket: "blocked-on-user", signal: "waiting on you", threadNoul: 0.71 })],
+      5,
+    )!;
+    expect(md).toContain("blocked-on-user");
+    expect(md).toContain("noul 0.71");
+  });
+
+  it("a sub-threshold noul neither promotes NOR drops — fail-open keeps today's behavior for that thread", () => {
+    const threads = [
+      mk({ session_id: "a", title: "Promoted", ageDays: 9, threadNoul: 0.9 }),
+      mk({ session_id: "b", title: "Below floor", ageDays: 1, threadNoul: 0.4 }),
+      mk({ session_id: "c", title: "Plain", ageDays: 2 }),
+    ];
+    const md = composeOpenThreadsDigest(threads, 2)!;
+    // promoted first; the 0.4 noul does NOT outrank recency but is NOT dropped either
+    const pos = (t: string) => md.indexOf(t);
+    expect(pos("Promoted")).toBeLessThan(pos("Below floor"));
+    expect(md).toContain("Below floor"); // the cap's second slot — today's rule
+    expect(md).not.toContain("Plain");
+  });
+
+  it("stale stays retirement-ranked even when promoted — promotion never outranks the retire flag", () => {
+    const threads = [
+      mk({ session_id: "s", title: "Stale promoted", bucket: "stale", ageDays: 30, threadNoul: 0.95 }),
+      mk({ session_id: "f", title: "Fresh plain", ageDays: 1 }),
+    ];
+    const md = composeOpenThreadsDigest(threads, 5)!;
+    const pos = (t: string) => md.indexOf(t);
+    expect(pos("Fresh plain")).toBeLessThan(pos("Stale promoted")); // stale still last
+  });
+
+  it("the deterministic derivation never calls Jev — mechanical purity guard on the module source", () => {
+    const source = fs.readFileSync(path.join(__dirname, "..", "opencode-plugin", "open_threads.ts"), "utf8");
+    expect(source).not.toMatch(/\bfetch\s*\(/);
+    expect(source).not.toMatch(/api\.typesafe/);
+    expect(source).not.toMatch(/from\s+"\.\.?\/.*jev/);
+  });
+});
+
+// ── the derived noul map: the amico-run pass writes it, the digest reads it ──
+
+describe("readThreadNoulMap — the ops-dir derived map (input feature, fail-open)", () => {
+  let tmp: string;
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "amico-thread-noul-"));
+    process.env.AMICODE_OPS_DIR = tmp;
+  });
+  afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    delete process.env.AMICODE_OPS_DIR;
+  });
+
+  it("reads the map the amico-run pass wrote (session id → noul)", () => {
+    fs.writeFileSync(
+      path.join(tmp, "thread-nouls.json"),
+      JSON.stringify({ schema_version: 1, generated_at: "2026-09-20T05:00:00.000Z", entries: { ses_a: 0.71, ses_b: 0.05 } }),
+    );
+    expect(readThreadNoulMap()).toEqual({ ses_a: 0.71, ses_b: 0.05 });
+  });
+
+  it("a missing or corrupt map is undefined — the digest degrades to today, never to a crash", () => {
+    expect(readThreadNoulMap()).toBeUndefined();
+    fs.writeFileSync(path.join(tmp, "thread-nouls.json"), "{not json");
+    expect(readThreadNoulMap()).toBeUndefined();
+  });
+});
+
+// ── wiring: amicode_context passes the map reader as the third input feature ──
+
+describe("amicode_context wiring — the thread-noul map rides the digest's input-feature seam", () => {
+  const source = fs.readFileSync(
+    path.join(__dirname, "..", "opencode-plugin", "amicode_context.ts"),
+    "utf8",
+  );
+
+  it("buildOpenThreadsBlock receives a threadNoulFor input map (the caller spends the network)", () => {
+    expect(source).toContain("buildOpenThreadsBlock(input.sessionID, undefined, threadNoulFor");
+  });
+});