omnius 1.0.891 → 1.0.892

package/dist/library.js

@@ -3505,6 +3505,9 @@ var init_jetson_monitor = __esm({
 function currentHostEnvironment() {
   return globalThis.process?.env ?? {};
 }
+function cpuOffloadAllowedFromEnv(env = currentHostEnvironment()) {
+  return env[OMNIUS_CPU_OFFLOAD_ALLOWED_ENV] === "1";
+}
 function normalizeGpuUuidList(value) {
   if (value === void 0)
     return void 0;
@@ -3541,12 +3544,13 @@ function isGpuUuidEnabled(uuid, enabledUuids = enabledGpuUuidsFromEnv()) {
     return true;
   return Boolean(uuid && enabledUuids.includes(uuid));
 }
-var OMNIUS_GPU_ENABLED_UUIDS_ENV, OMNIUS_GPU_PREFERRED_UUID_ENV;
+var OMNIUS_GPU_ENABLED_UUIDS_ENV, OMNIUS_GPU_PREFERRED_UUID_ENV, OMNIUS_CPU_OFFLOAD_ALLOWED_ENV;
 var init_gpu_selection = __esm({
   "packages/schemas/dist/gpu-selection.js"() {
     "use strict";
     OMNIUS_GPU_ENABLED_UUIDS_ENV = "OMNIUS_GPU_ENABLED_UUIDS";
     OMNIUS_GPU_PREFERRED_UUID_ENV = "OMNIUS_GPU_PREFERRED_UUID";
+    OMNIUS_CPU_OFFLOAD_ALLOWED_ENV = "OMNIUS_CPU_OFFLOAD_ALLOWED";
   }
 });
 
@@ -338743,7 +338747,7 @@ var init_ollama_pool = __esm({
             continue;
           }
           const PROBE_GRACE_MS = 3e4;
-          if (inst.state.inflight === 0 && Date.now() - inst.state.spawnedAtMs > PROBE_GRACE_MS && await this.isPartialVramSpilled(inst)) {
+          if (!cpuOffloadAllowedFromEnv() && inst.state.inflight === 0 && Date.now() - inst.state.spawnedAtMs > PROBE_GRACE_MS && await this.isPartialVramSpilled(inst)) {
             const reapedAtMs = Date.now();
             await inst.terminate();
             this.dropAffinityFor(inst.state.id);
@@ -352526,6 +352530,193 @@ var NativeOllamaToolCalls = class {
   }
 };
 
+// packages/orchestrator/dist/tool-argument-repair.js
+function shape2(parameters) {
+  const properties = parameters["properties"];
+  return {
+    properties: new Set(properties && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties) : []),
+    required: Array.isArray(parameters["required"]) ? parameters["required"].filter((key) => typeof key === "string") : []
+  };
+}
+function findBetterToolSchemaMatches(input) {
+  const keys4 = [...new Set(input.providedKeys.filter((key) => !key.startsWith("_")))];
+  if (!keys4.length)
+    return [];
+  const provided = new Set(keys4), requested = shape2(input.requestedParameters);
+  const requestedMissing = requested.required.filter((key) => !provided.has(key)).length;
+  const requestedUnknown = keys4.filter((key) => !requested.properties.has(key)).length;
+  if (!requestedMissing && !requestedUnknown)
+    return [];
+  const matches = /* @__PURE__ */ new Map();
+  for (const candidate of input.candidates) {
+    if (candidate.name === input.requestedToolName)
+      continue;
+    const target2 = shape2(candidate.parameters ?? {});
+    if (!target2.properties.size || target2.required.some((key) => !provided.has(key)) || keys4.some((key) => !target2.properties.has(key)))
+      continue;
+    matches.set(candidate.name, keys4.length * 2 + target2.required.length * 3);
+  }
+  return [...matches].sort(([left, leftScore], [right, rightScore]) => rightScore - leftScore || left.localeCompare(right)).slice(0, 3).map(([name]) => name);
+}
+
+// packages/orchestrator/dist/adjudication.js
+import { z as z18 } from "zod";
+var ADJUDICATION_TOOL_NAME = "adjudicate";
+var ADJUDICATION_ID_PATTERN = "^[A-Za-z0-9][A-Za-z0-9._:-]*$";
+function adjudicationArgumentRepairContract(error, argsHash) {
+  let issues = [];
+  try {
+    const parsed = JSON.parse(error);
+    if (Array.isArray(parsed))
+      issues = parsed.filter((issue3) => issue3 && typeof issue3 === "object");
+  } catch {
+  }
+  const parameters = adjudicationToolParameters();
+  const fields2 = issues.slice(0, 8).map((issue3) => {
+    const parts = Array.isArray(issue3.path) ? issue3.path : [];
+    let schema = parameters;
+    for (const part of parts) {
+      const next = typeof part === "number" ? schema?.items : schema?.properties?.[part];
+      schema = next && typeof next === "object" && !Array.isArray(next) ? next : void 0;
+    }
+    const constraints = schema && Object.fromEntries(Object.entries(schema).filter(([key]) => ["type", "minLength", "maxLength", "pattern", "enum", "minimum", "maximum", "minItems", "maxItems", "required"].includes(key)));
+    return {
+      path: parts.map((part) => typeof part === "number" ? `[${part}]` : part).join(".").replace(/\.\[/g, "[") || "arguments",
+      message: String(issue3.message ?? "invalid value"),
+      ...constraints ? { schema: constraints } : {}
+    };
+  });
+  return {
+    reason_code: "invalid_tool_arguments",
+    tool: ADJUDICATION_TOOL_NAME,
+    retryable: false,
+    ...argsHash ? { args_sha256: argsHash } : {},
+    fields: fields2.length ? fields2 : [{ path: "arguments", message: error.slice(0, 1400) }]
+  };
+}
+function formatAdjudicationArgumentRepair(error, argsHash) {
+  const contract = adjudicationArgumentRepairContract(error, argsHash);
+  return [
+    "[ADJUDICATION_ARGUMENT_REPAIR]",
+    JSON.stringify(contract),
+    ...contract.fields.map((field) => `${field.path}: ${field.message}`),
+    "Required keys for adjudicate: question, allowedOutcomes, evidence",
+    `IDs must be 1–96 characters matching ${ADJUDICATION_ID_PATTERN}; no whitespace or sentence-valued IDs.`,
+    'Format-only example: allowedOutcomes=["option_a","option_b"], context="option_a means the first described outcome; option_b means the second described outcome".',
+    "Keep the user's actual outcome descriptions in context/evidence. Choose explicit stable IDs yourself; do not drop or silently rewrite evidence, manufacture an outcome, or substitute another tool for a field-format error.",
+    "This exact argument instance cannot be retried unchanged. Correct the named values and retry immediately, or continue other substantive work. No panel ran for this rejected call."
+  ].join("\n");
+}
+var IdSchema = z18.string().trim().min(1).max(96).regex(new RegExp(ADJUDICATION_ID_PATTERN), "use a stable identifier without whitespace").describe("Stable identifier: 1–96 characters matching ^[A-Za-z0-9][A-Za-z0-9._:-]*$. Put prose descriptions in context/evidence, not IDs.");
+var AdjudicationEvidenceSchema = z18.object({
+  id: IdSchema,
+  content: z18.string().trim().min(1).max(32e3),
+  source: z18.string().trim().min(1).max(500),
+  kind: z18.enum([
+    "fact",
+    "observation",
+    "artifact",
+    "test_result",
+    "testimony",
+    "constraint",
+    "precedent"
+  ]).default("observation"),
+  observedAt: z18.string().trim().max(80).optional(),
+  sha256: z18.string().trim().regex(/^[a-fA-F0-9]{64}$/).optional(),
+  reliability: z18.number().min(0).max(1).optional()
+});
+var AdjudicationArgumentSchema = z18.object({
+  id: IdSchema,
+  position: z18.string().trim().min(1).max(160),
+  claim: z18.string().trim().min(1).max(4e3),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(64),
+  submittedBy: z18.string().trim().max(160).optional()
+});
+var AdjudicationConstituentInputSchema = z18.object({
+  id: IdSchema.optional(),
+  label: z18.string().trim().min(1).max(120),
+  question: z18.string().trim().min(1).max(2e3),
+  instructions: z18.string().trim().max(2e3).optional(),
+  evidenceIds: z18.array(IdSchema).min(1).max(128).optional(),
+  argumentIds: z18.array(IdSchema).max(64).optional(),
+  decisionRuleIds: z18.array(IdSchema).max(32).optional()
+});
+var AdjudicationInputSchema = z18.object({
+  caseId: IdSchema.optional(),
+  question: z18.string().trim().min(1).max(4e3).describe("The exact decision question. Ask one decision only."),
+  context: z18.string().trim().max(8e3).optional().describe("Neutral context needed to interpret the record, including each stable outcome ID's prose meaning."),
+  exclusions: z18.array(z18.string().trim().min(1).max(2e3)).max(32).default([]).describe("Explicitly excluded material or considerations that the panel must not admit."),
+  allowedOutcomes: z18.array(IdSchema).min(2).max(12).describe("Closed set of stable verdict IDs, for example option_a and option_b; preserve their prose meanings in context. insufficient_evidence is reserved by the tool."),
+  decisionRules: z18.array(z18.string().trim().min(1).max(2e3)).max(24).default([]).describe("Rules the judge must apply."),
+  burdenOfProof: z18.enum([
+    "best_supported",
+    "preponderance",
+    "clear_and_convincing",
+    "beyond_reasonable_doubt",
+    "risk_averse"
+  ]).default("best_supported"),
+  evidence: z18.array(AdjudicationEvidenceSchema).min(1).max(128),
+  arguments: z18.array(AdjudicationArgumentSchema).max(64).default([]),
+  constituents: z18.array(AdjudicationConstituentInputSchema).min(2).max(6).optional().describe("Optional independent focus assignments. Omit to let the case framer derive them."),
+  panelSize: z18.number().int().min(2).max(6).default(3),
+  maxConcurrency: z18.number().int().min(1).max(6).default(3),
+  quorum: z18.number().int().min(2).max(6).optional(),
+  constituentExecution: z18.enum(["auto", "full_sub_agent", "direct"]).default("auto").describe("auto uses the dedicated full_sub_agent profile when available, otherwise the direct bounded fallback."),
+  timeoutMs: z18.number().int().min(5e3).max(6e5).default(12e4),
+  maxTokensPerConstituent: z18.number().int().min(512).max(8192).default(2048),
+  maxJudgeTokens: z18.number().int().min(768).max(12288).default(3072)
+});
+function adjudicationToolParameters() {
+  const { $schema: _dialect, ...parameters } = z18.toJSONSchema(AdjudicationInputSchema, { target: "draft-7", io: "input" });
+  return parameters;
+}
+var PlannerResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  assignments: z18.array(z18.object({
+    id: IdSchema,
+    label: z18.string().trim().min(1).max(120),
+    question: z18.string().trim().min(1).max(2e3),
+    instructions: z18.string().trim().max(2e3).default(""),
+    evidenceIds: z18.array(IdSchema).min(1).max(128),
+    argumentIds: z18.array(IdSchema).max(64).default([]),
+    decisionRuleIds: z18.array(IdSchema).min(1).max(32)
+  })).min(2).max(6)
+});
+var ConstituentResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  constituentId: IdSchema,
+  assessment: z18.string().trim().min(20).max(8e3),
+  recommendation: IdSchema,
+  confidence: z18.number().min(0).max(1),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(128),
+  claims: z18.array(z18.object({
+    claim: z18.string().trim().min(1).max(2e3),
+    evidenceIds: z18.array(IdSchema).min(1).max(64)
+  })).min(1).max(24),
+  counterarguments: z18.array(z18.string().trim().min(1).max(2e3)).max(16).default([]),
+  uncertainties: z18.array(z18.string().trim().min(1).max(2e3)).max(16).default([])
+});
+var JudgeResponseSchema = z18.object({
+  schemaVersion: z18.literal(1),
+  caseId: IdSchema,
+  verdict: IdSchema,
+  confidence: z18.number().min(0).max(1),
+  rationale: z18.string().trim().min(30).max(12e3),
+  citedEvidenceIds: z18.array(IdSchema).min(1).max(128),
+  consideredConstituentIds: z18.array(IdSchema).min(2).max(6),
+  acceptedFindingIds: z18.array(IdSchema).max(144),
+  rejectedFindingIds: z18.array(IdSchema).max(144),
+  dissent: z18.array(z18.object({
+    constituentId: IdSchema,
+    recommendation: IdSchema,
+    summary: z18.string().trim().min(1).max(2e3)
+  })).max(6).default([]),
+  unresolvedQuestions: z18.array(z18.string().trim().min(1).max(2e3)).max(24).default([]),
+  nextAction: z18.string().trim().min(1).max(4e3)
+});
+
 // packages/orchestrator/dist/openai-chat-stream-parser.js
 var object10 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var MAX_PACKET_BYTES = 8388608;
@@ -355125,15 +355316,15 @@ var SelfImprovementArchive = class {
 import { createHash as createHash69, randomUUID as randomUUID41 } from "node:crypto";
 import { closeSync as closeSync12, existsSync as existsSync30, fsyncSync as fsyncSync6, mkdirSync as mkdirSync24, openSync as openSync12, readFileSync as readFileSync34, renameSync as renameSync12, unlinkSync as unlinkSync12, writeFileSync as writeFileSync22 } from "node:fs";
 import { dirname as dirname23, join as join40 } from "node:path";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // packages/orchestrator/dist/commandEvidenceReceipt.js
-import { z as z18 } from "zod";
-var token2 = z18.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
-var timestamp2 = z18.string().datetime({ offset: true });
-var integer3 = z18.number().int().safe();
-var CommandEvidenceReceiptSchema = z18.object({
-  schema: z18.literal("omnius.command-evidence-receipt.v1"),
+import { z as z19 } from "zod";
+var token2 = z19.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
+var timestamp2 = z19.string().datetime({ offset: true });
+var integer3 = z19.number().int().safe();
+var CommandEvidenceReceiptSchema = z19.object({
+  schema: z19.literal("omnius.command-evidence-receipt.v1"),
   command: token2,
   canonicalCommand: token2,
   cwd: token2,
@@ -355141,20 +355332,20 @@ var CommandEvidenceReceiptSchema = z18.object({
   primaryCommand: token2.optional(),
   primaryExitCode: integer3.nullable().optional(),
   runnerExitCode: integer3.nullable().optional(),
-  primaryExitProvenance: z18.enum(["runner_process", "trailing_exit_reporter"]).optional(),
-  pipefail: z18.boolean(),
-  timedOut: z18.boolean(),
+  primaryExitProvenance: z19.enum(["runner_process", "trailing_exit_reporter"]).optional(),
+  pipefail: z19.boolean(),
+  timedOut: z19.boolean(),
   startedAtIso: timestamp2,
   finishedAtIso: timestamp2,
-  shellRunId: z18.string().uuid().optional(),
+  shellRunId: z19.string().uuid().optional(),
   timeoutMs: integer3.positive().nullable().optional(),
-  cancelled: z18.boolean().optional(),
+  cancelled: z19.boolean().optional(),
   signal: token2.nullable().optional(),
-  observation: z18.object({ kind: z18.literal("search_no_match") }).strict().optional(),
+  observation: z19.object({ kind: z19.literal("search_no_match") }).strict().optional(),
   outputRef: token2.optional(),
-  observedPaths: z18.array(token2).optional(),
-  artifactHashes: z18.array(z18.object({ path: token2, sha256: z18.string().regex(/^[a-f0-9]{64}$/) }).strict()).optional(),
-  declaredVerification: z18.object({ protocol: z18.literal("OMNIUS_VERIFICATION_RESULT"), outcome: z18.enum(["pass", "fail"]) }).strict().optional()
+  observedPaths: z19.array(token2).optional(),
+  artifactHashes: z19.array(z19.object({ path: token2, sha256: z19.string().regex(/^[a-f0-9]{64}$/) }).strict()).optional(),
+  declaredVerification: z19.object({ protocol: z19.literal("OMNIUS_VERIFICATION_RESULT"), outcome: z19.enum(["pass", "fail"]) }).strict().optional()
 }).strict().refine((value) => Date.parse(value.finishedAtIso) >= Date.parse(value.startedAtIso));
 function parseCommandEvidenceReceipt(value) {
   try {
@@ -355167,21 +355358,21 @@ function parseCommandEvidenceReceipt(value) {
 
 // packages/orchestrator/dist/conversationReportEvidence.js
 var SCHEMA = "omnius.conversation-report-evidence.v2";
-var token3 = z19.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
-var timestamp3 = z19.string().datetime({ offset: true });
-var integer4 = z19.number().int().safe();
-var identitySchema = z19.object({ sessionId: token3, runId: token3, taskEpoch: integer4.nonnegative() }).strict();
-var reference = z19.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
-var paths = z19.array(token3);
-var deliveryReceiptSchema = z19.object({
-  schema: z19.literal("omnius.completion-delivery-receipt.v1"),
+var token3 = z20.string().refine((value) => value.trim().length > 0 && !value.includes("\0"));
+var timestamp3 = z20.string().datetime({ offset: true });
+var integer4 = z20.number().int().safe();
+var identitySchema = z20.object({ sessionId: token3, runId: token3, taskEpoch: integer4.nonnegative() }).strict();
+var reference = z20.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+var paths = z20.array(token3);
+var deliveryReceiptSchema = z20.object({
+  schema: z20.literal("omnius.completion-delivery-receipt.v1"),
   provider: token3,
   target: token3,
   receiptId: token3,
   deliveredAtIso: timestamp3,
   artifactPaths: paths.optional()
 }).strict();
-var objectiveEvidenceKindSchema = z19.enum([
+var objectiveEvidenceKindSchema = z20.enum([
   "visible_response",
   "observation",
   "mutation",
@@ -355193,79 +355384,79 @@ var objectiveEvidenceKindSchema = z19.enum([
   "authenticated_session",
   "human_input"
 ]);
-var externalEffectReceiptSchema = z19.object({
-  schema: z19.literal("omnius.external-effect-receipt.v1"),
+var externalEffectReceiptSchema = z20.object({
+  schema: z20.literal("omnius.external-effect-receipt.v1"),
   effectKind: token3,
   semanticTarget: token3,
   idempotencyKey: token3,
-  effectState: z19.enum(["pending", "applied", "absent", "unknown"]),
+  effectState: z20.enum(["pending", "applied", "absent", "unknown"]),
   artifactRevision: token3.optional(),
   evidenceId: token3,
-  criterionIds: z19.array(token3),
-  evidenceKinds: z19.array(objectiveEvidenceKindSchema).optional(),
-  destination: z19.object({ url: z19.string().url(), provider: token3 }).strict().optional()
+  criterionIds: z20.array(token3),
+  evidenceKinds: z20.array(objectiveEvidenceKindSchema).optional(),
+  destination: z20.object({ url: z20.string().url(), provider: token3 }).strict().optional()
 }).strict();
-var verificationReceiptSchema = z19.object({
-  schema: z19.literal("omnius.verification-receipt.v1"),
+var verificationReceiptSchema = z20.object({
+  schema: z20.literal("omnius.verification-receipt.v1"),
   evidenceId: token3,
   criterionId: token3,
   artifactEvidenceId: token3,
   artifactRevision: token3.optional(),
   verifierMethod: token3,
-  outcome: z19.enum(["passed", "artifact_failed", "verifier_invalid", "downstream_auth_required", "inconclusive"]),
-  evidenceIds: z19.array(token3),
-  evidenceKinds: z19.array(objectiveEvidenceKindSchema).optional()
+  outcome: z20.enum(["passed", "artifact_failed", "verifier_invalid", "downstream_auth_required", "inconclusive"]),
+  evidenceIds: z20.array(token3),
+  evidenceKinds: z20.array(objectiveEvidenceKindSchema).optional()
 }).strict();
-var externalBlockerSchema = z19.object({
-  schema: z19.literal("omnius.objective-external-blocker.v1"),
-  criterionIds: z19.array(token3),
+var externalBlockerSchema = z20.object({
+  schema: z20.literal("omnius.objective-external-blocker.v1"),
+  criterionIds: z20.array(token3),
   evidenceId: token3,
   blockerKind: token3,
-  retryable: z19.boolean()
+  retryable: z20.boolean()
 }).strict();
-var evidenceSchema = z19.object({
+var evidenceSchema = z20.object({
   id: token3,
-  kind: z19.literal("tool_result"),
+  kind: z20.literal("tool_result"),
   observedAtIso: timestamp3,
-  summary: z19.string(),
+  summary: z20.string(),
   toolName: token3,
-  success: z19.boolean().optional(),
+  success: z20.boolean().optional(),
   rawRef: token3.optional(),
   targetPaths: paths.optional(),
-  role: z19.enum(["observation", "verification", "mutation", "blocker", "delivery"]).optional(),
+  role: z20.enum(["observation", "verification", "mutation", "blocker", "delivery"]).optional(),
   family: token3.optional(),
-  verificationImpact: z19.enum(["invalidates", "neutral"]).optional(),
-  metrics: z19.record(z19.string(), z19.unknown()).optional(),
+  verificationImpact: z20.enum(["invalidates", "neutral"]).optional(),
+  metrics: z20.record(z20.string(), z20.unknown()).optional(),
   receipt: CommandEvidenceReceiptSchema.optional(),
   deliveryReceipt: deliveryReceiptSchema.optional(),
-  progressClass: z19.enum(["work_product", "control_bookkeeping", "observation", "blocker"]).optional(),
-  criterionIds: z19.array(token3).optional(),
-  objectiveEvidenceKinds: z19.array(objectiveEvidenceKindSchema).optional(),
+  progressClass: z20.enum(["work_product", "control_bookkeeping", "observation", "blocker"]).optional(),
+  criterionIds: z20.array(token3).optional(),
+  objectiveEvidenceKinds: z20.array(objectiveEvidenceKindSchema).optional(),
   externalEffectReceipt: externalEffectReceiptSchema.optional(),
   verificationReceipt: verificationReceiptSchema.optional(),
   externalBlocker: externalBlockerSchema.optional()
 }).strict();
-var chunkSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var chunkSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   previousReference: reference.nullable(),
   sequence: integer4.positive(),
   startEntry: integer4.nonnegative(),
   entryCount: integer4.nonnegative(),
-  entries: z19.array(z19.object({ callId: token3, evidence: evidenceSchema }).strict()),
+  entries: z20.array(z20.object({ callId: token3, evidence: evidenceSchema }).strict()),
   ledgerCreatedAtIso: timestamp3,
   updatedAtIso: timestamp3,
   recoveryGap: token3.max(500).optional()
 }).strict();
-var pointerSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var pointerSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   reference,
   entryCount: integer4.nonnegative(),
   chunkCount: integer4.positive()
 }).strict();
-var pendingSchema = z19.object({
-  schema: z19.literal(SCHEMA),
+var pendingSchema = z20.object({
+  schema: z20.literal(SCHEMA),
   identity: identitySchema,
   previousReference: reference.nullable(),
   previousEntryCount: integer4.nonnegative(),
@@ -355472,7 +355663,7 @@ var ConversationReportEvidence = class {
       this.persistedChunkCount = pointer.chunkCount;
       this.persistedGap = chain[0].recoveryGap;
     } catch (error) {
-      const detail = error instanceof z19.ZodError || error instanceof SyntaxError ? "Saved report evidence has invalid fields or contains task authority." : error instanceof Error ? error.message : String(error);
+      const detail = error instanceof z20.ZodError || error instanceof SyntaxError ? "Saved report evidence has invalid fields or contains task authority." : error instanceof Error ? error.message : String(error);
       this.recoveryGap = `Earlier conversation evidence could not be restored: ${detail}${pendingGap ? ` ${pendingGap}` : ""}`.slice(0, 500);
     }
   }
@@ -355607,7 +355798,7 @@ init_dist5();
 import { createHash as createHash71 } from "node:crypto";
 import { closeSync as closeSync14, existsSync as existsSync32, fsyncSync as fsyncSync8, lstatSync as lstatSync4, mkdirSync as mkdirSync26, openSync as openSync14, readFileSync as readFileSync36, readdirSync as readdirSync11, realpathSync as realpathSync10, renameSync as renameSync14, statSync as statSync17, unlinkSync as unlinkSync14, writeFileSync as writeFileSync24 } from "node:fs";
 import { dirname as dirname24, isAbsolute as isAbsolute13, join as join42, relative as relative9, resolve as resolve27 } from "node:path";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // packages/orchestrator/dist/contentAddressedArtifactStore.js
 import { createHash as createHash70, randomUUID as randomUUID42 } from "node:crypto";
@@ -356478,10 +356669,10 @@ var equal = (a, b) => canonical6(a) === canonical6(b);
 function fail3(reason) {
   throw new Error(`feature_workflow_${reason}`);
 }
-var token4 = z20.string().trim().min(1).max(1e3);
-var integer5 = z20.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var ref7 = z20.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
-var digest5 = z20.string().regex(/^[a-f0-9]{64}$/);
+var token4 = z21.string().trim().min(1).max(1e3);
+var integer5 = z21.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var ref7 = z21.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+var digest5 = z21.string().regex(/^[a-f0-9]{64}$/);
 function featureWorkflowInputArtifactsHash(artifacts) {
   return createHash71("sha256").update(JSON.stringify([...artifacts].sort((a, b) => a.slotId.localeCompare(b.slotId)).map((a) => ({
     slotId: a.slotId,
@@ -356489,13 +356680,13 @@ function featureWorkflowInputArtifactsHash(artifacts) {
     content: a.content
   })))).digest("hex");
 }
-var identitySchema2 = z20.object({
+var identitySchema2 = z21.object({
   sessionId: token4,
   runId: token4,
   taskEpoch: integer5,
   generation: integer5
 }).strict();
-var bindingSchema = z20.object({
+var bindingSchema = z21.object({
   parentOperationId: token4,
   parentRunId: token4,
   parentGeneration: integer5,
@@ -356503,22 +356694,22 @@ var bindingSchema = z20.object({
   cardId: token4,
   planReference: ref7,
   cardContract: digest5,
-  inputSlots: z20.record(token4, ref7),
-  kind: z20.enum(["work", "review", "verification"]),
-  readOnly: z20.boolean(),
-  ownedFiles: z20.array(token4).max(128),
+  inputSlots: z21.record(token4, ref7),
+  kind: z21.enum(["work", "review", "verification"]),
+  readOnly: z21.boolean(),
+  ownedFiles: z21.array(token4).max(128),
   inputArtifactsHash: digest5
 }).strict();
 var childSchema = bindingSchema.extend({
-  schema: z20.literal("omnius.feature-workflow-child-receipt.v1"),
+  schema: z21.literal("omnius.feature-workflow-child-receipt.v1"),
   childId: token4,
   childRunId: token4,
   childTaskEpoch: integer5,
   childInputHash: digest5,
-  status: z20.enum(["completed", "failed", "cancelled", "running"]),
+  status: z21.enum(["completed", "failed", "cancelled", "running"]),
   terminalReceiptId: token4.optional()
 }).strict();
-var slotSchema = z20.object({
+var slotSchema = z21.object({
   reference: ref7,
   cardId: token4,
   cardContract: digest5,
@@ -356527,61 +356718,61 @@ var slotSchema = z20.object({
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var operationSchema = z20.object({
+var operationSchema = z21.object({
   binding: bindingSchema,
   actorId: token4,
   toolName: token4,
   command: token4.optional(),
-  effect: z20.enum(["read_only", "local_mutation", "external_effect"]),
-  state: z20.enum(["pending", "interrupted"]),
+  effect: z21.enum(["read_only", "local_mutation", "external_effect"]),
+  state: z21.enum(["pending", "interrupted"]),
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var resultSchema = z20.object({
+var resultSchema = z21.object({
   binding: bindingSchema,
   actorId: token4,
-  success: z20.boolean(),
+  success: z21.boolean(),
   receiptReference: ref7,
-  reviewDisposition: z20.enum(["approved", "changes_requested"]).optional(),
+  reviewDisposition: z21.enum(["approved", "changes_requested"]).optional(),
   childReceipt: childSchema.optional(),
-  commandReceipt: z20.unknown().optional(),
+  commandReceipt: z21.unknown().optional(),
   childReportReference: ref7.optional(),
-  blockers: z20.array(token4).max(96),
-  unresolvedQuestions: z20.array(token4).max(32),
+  blockers: z21.array(token4).max(96),
+  unresolvedQuestions: z21.array(token4).max(32),
   mutationSequence: integer5,
   workspaceRevision: digest5
 }).strict();
-var commandReceiptSchema = z20.object({
-  schema: z20.literal("omnius.command-evidence-receipt.v1"),
+var commandReceiptSchema = z21.object({
+  schema: z21.literal("omnius.command-evidence-receipt.v1"),
   command: token4,
   canonicalCommand: token4,
   cwd: token4,
-  pipefail: z20.boolean(),
-  timedOut: z20.boolean(),
-  cancelled: z20.boolean().optional(),
-  startedAtIso: z20.string().datetime(),
-  finishedAtIso: z20.string().datetime(),
-  exitCode: z20.number().int().nullable().optional(),
-  primaryExitCode: z20.number().int().nullable().optional()
+  pipefail: z21.boolean(),
+  timedOut: z21.boolean(),
+  cancelled: z21.boolean().optional(),
+  startedAtIso: z21.string().datetime(),
+  finishedAtIso: z21.string().datetime(),
+  exitCode: z21.number().int().nullable().optional(),
+  primaryExitCode: z21.number().int().nullable().optional()
 }).passthrough();
-var checkpointSchema = z20.object({
-  schema: z20.literal(SCHEMA2),
+var checkpointSchema = z21.object({
+  schema: z21.literal(SCHEMA2),
   identity: identitySchema2,
   boardRunId: token4,
   planReference: ref7,
   sequence: integer5,
   mutationSequence: integer5,
-  slots: z20.record(token4, slotSchema),
-  operations: z20.record(token4, operationSchema),
-  results: z20.record(token4, resultSchema),
-  recentSettlements: z20.array(z20.object({ operationId: token4, resultHash: digest5 }).strict()).max(256),
-  retired: z20.object({
+  slots: z21.record(token4, slotSchema),
+  operations: z21.record(token4, operationSchema),
+  results: z21.record(token4, resultSchema),
+  recentSettlements: z21.array(z21.object({ operationId: token4, resultHash: digest5 }).strict()).max(256),
+  retired: z21.object({
     reason: token4,
-    at: z20.string().datetime(),
+    at: z21.string().datetime(),
     toEpoch: integer5.optional()
   }).strict().optional(),
   workingDir: token4,
-  adoptions: z20.array(z20.object({
+  adoptions: z21.array(z21.object({
     from: identitySchema2,
     to: identitySchema2,
     sourceCheckpointReference: ref7,
@@ -356858,8 +357049,8 @@ var FeatureWorkflowController = class {
     return this.state;
   }
   assertCurrentSelector() {
-    const actual = existsSync32(this.selectorPath) ? z20.object({
-      schema: z20.literal(SELECTOR_SCHEMA),
+    const actual = existsSync32(this.selectorPath) ? z21.object({
+      schema: z21.literal(SELECTOR_SCHEMA),
       checkpointReference: ref7
     }).strict().parse(JSON.parse(readFileSync36(this.selectorPath, "utf8"))).checkpointReference : null;
     if (actual !== this.selectorReference) {
@@ -356995,8 +357186,8 @@ var FeatureWorkflowController = class {
     try {
       if (!existsSync32(this.selectorPath)) {
         const matches = this.selectorCandidates().filter((file) => {
-          const selector2 = z20.object({
-            schema: z20.literal(SELECTOR_SCHEMA),
+          const selector2 = z21.object({
+            schema: z21.literal(SELECTOR_SCHEMA),
             checkpointReference: ref7
           }).strict().parse(JSON.parse(readFileSync36(join42(dirname24(this.selectorPath), file), "utf8")));
           const state2 = checkpointSchema.parse(JSON.parse(this.store.read(selector2.checkpointReference).content));
@@ -357008,8 +357199,8 @@ var FeatureWorkflowController = class {
           fail3("same_run_checkpoint_not_unique");
         this.selectorPath = join42(dirname24(this.selectorPath), matches[0]);
       }
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(this.selectorPath, "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357063,8 +357254,8 @@ var FeatureWorkflowController = class {
       return [];
     const results = [];
     for (const file of this.selectorCandidates()) {
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(join42(directory, file), "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357091,8 +357282,8 @@ var FeatureWorkflowController = class {
       fail3("continuation_not_found");
     const matches = [];
     for (const file of this.selectorCandidates()) {
-      const selector = z20.object({
-        schema: z20.literal(SELECTOR_SCHEMA),
+      const selector = z21.object({
+        schema: z21.literal(SELECTOR_SCHEMA),
         checkpointReference: ref7
       }).strict().parse(JSON.parse(readFileSync36(join42(directory, file), "utf8")));
       const state = checkpointSchema.parse(JSON.parse(this.store.read(selector.checkpointReference).content));
@@ -357145,7 +357336,7 @@ var FeatureWorkflowController = class {
       if (card.phase === "implementation" && !card.ownedFiles.some((path7) => failed.verifier.targetPaths.some((target2) => resolve27(this.options.workingDir, path7) === resolve27(this.options.workingDir, target2))))
         fail3("repair_not_failed_verifier_target");
     }
-    const reason = z20.string().trim().min(1).max(4e3).parse(input.reason);
+    const reason = z21.string().trim().min(1).max(4e3).parse(input.reason);
     const affected = /* @__PURE__ */ new Set([card.id]);
     for (const item of compileFeatureWorkflow(plan).cards) {
       const candidate = plan.cards.find((c) => featureWorkflowCardId(plan, c.id) === item.id);
@@ -359177,7 +359368,7 @@ function checkDoomLoop(context) {
 // packages/orchestrator/dist/steeringIntake.js
 import { appendFileSync as appendFileSync4, existsSync as existsSync34, mkdirSync as mkdirSync28, readFileSync as readFileSync39 } from "node:fs";
 import { join as join44 } from "node:path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 function classifySteeringIntent(content, requestedIntent) {
   void content;
   return requestedIntent ?? "context_only";
@@ -359189,12 +359380,12 @@ function steeringGatesOldPlan(intent) {
   return intent !== "cancel";
 }
 var LEDGER_FILE = "steering-ledger.jsonl";
-var SteeringInterpretationSchema = z21.object({
-  inference: z21.string().trim().min(1),
-  runnerInstruction: z21.string().trim().min(1),
-  conflicts: z21.array(z21.string().trim().min(1)).optional().default([]),
-  alternatives: z21.array(z21.string().trim().min(1)).optional().default([]),
-  memoryNote: z21.string().trim().min(1).optional()
+var SteeringInterpretationSchema = z22.object({
+  inference: z22.string().trim().min(1),
+  runnerInstruction: z22.string().trim().min(1),
+  conflicts: z22.array(z22.string().trim().min(1)).optional().default([]),
+  alternatives: z22.array(z22.string().trim().min(1)).optional().default([]),
+  memoryNote: z22.string().trim().min(1).optional()
 });
 function appendSteeringLedgerEntry(repoRoot, entry) {
   try {
@@ -359207,13 +359398,17 @@ function appendSteeringLedgerEntry(repoRoot, entry) {
 }
 
 // packages/orchestrator/dist/steeringEvidence.js
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // packages/orchestrator/dist/typed-model-output.js
 var STEERING_RECONCILIATION_REGION = "steering_reconciliation";
 var OPEN = "[STEERING_RECONCILIATION";
 var CLOSE = "[/STEERING_RECONCILIATION";
 var RESERVED_INTERNAL_LINE_MARKERS = [
+  "[ADJUDICATION_ARGUMENT_REPAIR]",
+  "[ADJUDICATION_INVALID_REPLAY]",
+  "[HUMAN_RESPONSE_REQUIRED]",
+  "[HUMAN_RESPONSE_TURN_REQUIRED]",
   "[STEERING_RECONCILIATION_REQUIRED]",
   "[STEERING_REPLAN_TURN_REQUIRED]",
   "[STEERING_CLARIFICATION_REQUIRED]",
@@ -359621,38 +359816,38 @@ ${marker}`);
 
 // packages/orchestrator/dist/steeringEvidence.js
 var STEERING_CHECKPOINT_SCHEMA = "omnius.steering-checkpoint.v1";
-var identity = z22.string().min(1).max(500).refine((value) => value === value.trim());
-var epoch = z22.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var intake = z22.object({
+var identity = z23.string().min(1).max(500).refine((value) => value === value.trim());
+var epoch = z23.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var intake = z23.object({
   inputId: identity,
-  content: z22.string().min(1),
-  source: z22.string().min(1),
-  receivedAt: z22.string().datetime(),
-  intent: z22.enum(["clarify", "append", "context_only", "constraint", "priority_change", "redirect", "replace", "cancel"]),
-  state: z22.enum(["received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed", "superseded", "cancelled"]),
-  allowTaskReplacement: z22.boolean().optional(),
+  content: z23.string().min(1),
+  source: z23.string().min(1),
+  receivedAt: z23.string().datetime(),
+  intent: z23.enum(["clarify", "append", "context_only", "constraint", "priority_change", "redirect", "replace", "cancel"]),
+  state: z23.enum(["received", "queued", "acknowledged", "visible_in_request", "reconciliation_required", "reconciled", "first_affected_action", "consumed", "superseded", "cancelled"]),
+  allowTaskReplacement: z23.boolean().optional(),
   taskEpoch: epoch
 });
-var call = z22.object({
+var call = z23.object({
   id: identity,
   name: identity,
-  arguments: z22.record(z22.string(), z22.unknown()),
-  executionArguments: z22.record(z22.string(), z22.unknown()).optional(),
-  state: z22.enum(["pending", "running", "completed"]),
-  success: z22.boolean().optional()
+  arguments: z23.record(z23.string(), z23.unknown()),
+  executionArguments: z23.record(z23.string(), z23.unknown()).optional(),
+  state: z23.enum(["pending", "running", "completed"]),
+  success: z23.boolean().optional()
 }).refine((value) => value.state === "completed" === (value.success !== void 0));
-var activeSchema = z22.object({
+var activeSchema = z23.object({
   input: intake,
-  relatedInputs: z22.array(intake).max(127).optional(),
+  relatedInputs: z23.array(intake).max(127).optional(),
   historyStartIndex: epoch.optional(),
   appliedTurn: epoch,
-  requiresReconciliation: z22.boolean(),
-  gatesOldPlan: z22.boolean(),
-  visibleRequestTurns: z22.array(epoch),
-  reconciliation: z22.unknown().optional(),
+  requiresReconciliation: z23.boolean(),
+  gatesOldPlan: z23.boolean(),
+  visibleRequestTurns: z23.array(epoch),
+  reconciliation: z23.unknown().optional(),
   reconciledTurn: epoch.optional(),
-  firstAffectedAction: z22.object({ toolName: identity, turn: epoch }).optional(),
-  evidence: z22.object({ phases: z22.number().int().min(1).max(3), calls: z22.array(call).min(1).max(12) }).optional()
+  firstAffectedAction: z23.object({ toolName: identity, turn: epoch }).optional(),
+  evidence: z23.object({ phases: z23.number().int().min(1).max(3), calls: z23.array(call).min(1).max(12) }).optional()
 });
 function isSteeringScopeResolved(active) {
   const decision2 = active.reconciliation;
@@ -359667,7 +359862,7 @@ function renderSteeringReconciliationProtocol(inputId) {
     taskDisposition: "continue"
   });
   return [
-    "Before any tool call, respond with exactly one structured reconciliation and no tool calls in that response:",
+    "First answer the latest user briefly in ordinary visible prose; then include exactly one internal structured reconciliation. Include no tool calls in that response:",
     "[STEERING_RECONCILIATION]",
     template,
     "[/STEERING_RECONCILIATION]",
@@ -359686,14 +359881,14 @@ function steeringEvidenceArgumentsKey(value) {
   return JSON.stringify(value) ?? "undefined";
 }
 function validateSteeringCheckpoint(value, expected) {
-  const parsed = z22.object({
-    schema: z22.literal(STEERING_CHECKPOINT_SCHEMA),
+  const parsed = z23.object({
+    schema: z23.literal(STEERING_CHECKPOINT_SCHEMA),
     runId: identity,
     sessionId: identity,
     taskEpoch: epoch,
     active: activeSchema,
-    goal: z22.string().min(1).max(16e3),
-    messages: z22.array(z22.unknown()).min(1).max(1e5)
+    goal: z23.string().min(1).max(16e3),
+    messages: z23.array(z23.unknown()).min(1).max(1e5)
   }).parse(value);
   if (parsed.runId !== expected.runId || parsed.sessionId !== expected.sessionId || parsed.taskEpoch !== expected.taskEpoch)
     throw new Error("steering_checkpoint_identity_mismatch");
@@ -365409,7 +365604,7 @@ function reconcileShellExecutionOutcome(command, result) {
 }
 
 // packages/orchestrator/dist/agenticRunner.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 init_ollama_pool();
 
 // packages/orchestrator/dist/personality.js
@@ -366153,7 +366348,7 @@ function buildPhaseSkillGuidance(input) {
 import { createHash as createHash87 } from "node:crypto";
 import { existsSync as existsSync40, readFileSync as readFileSync46 } from "node:fs";
 import { join as join50 } from "node:path";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var deliveryRealityStates = [
   "simulation_only",
   "hardware_integrated",
@@ -366169,70 +366364,70 @@ var acceptanceLayers = [
   "hardware_in_loop",
   "documentation"
 ];
-var sourceSchema = z23.object({
-  id: z23.string().min(1),
-  kind: z23.enum(["local_contract", "official_vendor", "third_party", "generated"]),
-  pathOrUrl: z23.string().min(1),
-  revision: z23.string().min(1).optional(),
-  hash: z23.string().min(8).optional()
+var sourceSchema = z24.object({
+  id: z24.string().min(1),
+  kind: z24.enum(["local_contract", "official_vendor", "third_party", "generated"]),
+  pathOrUrl: z24.string().min(1),
+  revision: z24.string().min(1).optional(),
+  hash: z24.string().min(8).optional()
 });
-var contractSchema = z23.object({
-  id: z23.string().min(1),
-  productSeries: z23.string().min(1),
-  sourceId: z23.string().min(1),
-  declaredCommands: z23.array(z23.string().min(1)).default([]),
-  declaredParameters: z23.array(z23.string().min(1)).default([]),
-  declaredModelFormats: z23.array(z23.string().min(1)).default([])
+var contractSchema = z24.object({
+  id: z24.string().min(1),
+  productSeries: z24.string().min(1),
+  sourceId: z24.string().min(1),
+  declaredCommands: z24.array(z24.string().min(1)).default([]),
+  declaredParameters: z24.array(z24.string().min(1)).default([]),
+  declaredModelFormats: z24.array(z24.string().min(1)).default([])
 });
-var acceptanceSchema = z23.object({
-  id: z23.string().min(1),
-  layer: z23.enum(acceptanceLayers),
-  requiredFor: z23.array(z23.enum(deliveryRealityStates)).min(1),
+var acceptanceSchema = z24.object({
+  id: z24.string().min(1),
+  layer: z24.enum(acceptanceLayers),
+  requiredFor: z24.array(z24.enum(deliveryRealityStates)).min(1),
   /** Canonical commands whose successful receipts prove this layer ran. */
-  verificationCommands: z23.array(z23.string().min(1)).min(1),
-  safetyInterlock: z23.string().min(1).optional()
+  verificationCommands: z24.array(z24.string().min(1)).min(1),
+  safetyInterlock: z24.string().min(1).optional()
 });
-var inspectionSchema = z23.object({
-  id: z23.string().min(1),
-  boundary: z23.string().min(1),
-  targetPaths: z23.array(z23.string().min(1)).min(1),
-  proves: z23.string().min(1)
+var inspectionSchema = z24.object({
+  id: z24.string().min(1),
+  boundary: z24.string().min(1),
+  targetPaths: z24.array(z24.string().min(1)).min(1),
+  proves: z24.string().min(1)
 });
-var contradictionCheckSchema = z23.object({
-  id: z23.string().min(1),
-  question: z23.string().min(1),
-  inspectionIds: z23.array(z23.string().min(1)).min(1)
+var contradictionCheckSchema = z24.object({
+  id: z24.string().min(1),
+  question: z24.string().min(1),
+  inspectionIds: z24.array(z24.string().min(1)).min(1)
 });
-var subjectSchema = z23.object({
-  productSeries: z23.string().min(1),
-  commands: z23.array(z23.string().min(1)).default([]),
-  parameters: z23.array(z23.string().min(1)).default([]),
-  modelFormats: z23.array(z23.string().min(1)).default([])
+var subjectSchema = z24.object({
+  productSeries: z24.string().min(1),
+  commands: z24.array(z24.string().min(1)).default([]),
+  parameters: z24.array(z24.string().min(1)).default([]),
+  modelFormats: z24.array(z24.string().min(1)).default([])
 });
-var claimSchema = z23.object({
-  id: z23.string().min(1),
-  subjects: z23.array(subjectSchema).min(1),
-  state: z23.enum(deliveryRealityStates),
-  contractId: z23.string().min(1).optional(),
-  sourceIds: z23.array(z23.string().min(1)).min(1),
-  evidenceIds: z23.array(z23.string().min(1)).default([]),
-  requiredAcceptanceIds: z23.array(z23.string().min(1)).default([]),
+var claimSchema = z24.object({
+  id: z24.string().min(1),
+  subjects: z24.array(subjectSchema).min(1),
+  state: z24.enum(deliveryRealityStates),
+  contractId: z24.string().min(1).optional(),
+  sourceIds: z24.array(z24.string().min(1)).min(1),
+  evidenceIds: z24.array(z24.string().min(1)).default([]),
+  requiredAcceptanceIds: z24.array(z24.string().min(1)).default([]),
   /** Source boundaries that must be freshly read before this claim is true. */
-  requiredInspectionIds: z23.array(z23.string().min(1)).default([]),
+  requiredInspectionIds: z24.array(z24.string().min(1)).default([]),
   /** Falsification checks that must be grounded in those source inspections. */
-  requiredContradictionCheckIds: z23.array(z23.string().min(1)).default([]),
-  blockedReason: z23.string().min(1).optional()
+  requiredContradictionCheckIds: z24.array(z24.string().min(1)).default([]),
+  blockedReason: z24.string().min(1).optional()
 });
-var deliveryCoverageManifestSchema = z23.object({
+var deliveryCoverageManifestSchema = z24.object({
   // Version 1 remains readable for existing workspaces. Version 2 activates
   // claim-driven source inspection and falsification gates.
-  schemaVersion: z23.union([z23.literal(1), z23.literal(2)]),
-  sources: z23.array(sourceSchema),
-  contracts: z23.array(contractSchema),
-  acceptance: z23.array(acceptanceSchema),
-  inspections: z23.array(inspectionSchema).default([]),
-  contradictionChecks: z23.array(contradictionCheckSchema).default([]),
-  claims: z23.array(claimSchema)
+  schemaVersion: z24.union([z24.literal(1), z24.literal(2)]),
+  sources: z24.array(sourceSchema),
+  contracts: z24.array(contractSchema),
+  acceptance: z24.array(acceptanceSchema),
+  inspections: z24.array(inspectionSchema).default([]),
+  contradictionChecks: z24.array(contradictionCheckSchema).default([]),
+  claims: z24.array(claimSchema)
 });
 function canonicalPath(path7) {
   return String(path7 ?? "").trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
@@ -388296,6 +388491,10 @@ var AgenticRunner = class _AgenticRunner {
    */
   _immediateSteeringWakeInputId = null;
   _steeringSequence = 0;
+  /** Explicit foreground human input is answered before optional advice/actions. */
+  _pendingSteeringReply = null;
+  _steeringReplyTurn = null;
+  _adjudicationArgumentRepair = null;
   _taskEpoch = 0;
   _exclusiveTaskOwner = null;
   _hasStartedTask = false;
@@ -388470,6 +388669,8 @@ var AgenticRunner = class _AgenticRunner {
   _desktopVerificationObservation = null;
   _desktopVerificationPending = null;
   _trajectoryGeneratedGrounding = null;
+  _trajectoryGroundingRequest = null;
+  _virtualContextRequest = null;
   _taskWorkOperationBindings = /* @__PURE__ */ new Map();
   _taskWorkDispatchUnits = /* @__PURE__ */ new Map();
   // -- File State Registry (SWE-agent inspired) --
@@ -392946,7 +393147,7 @@ ${read.content}`;
       request.maxTokens = Math.min(outputIntent, configuredCeiling);
     }
     const steering = this._activeSteering;
-    const maskSteeringTools = Boolean(steering?.input.taskEpoch === this._taskEpoch && steering.gatesOldPlan && steering.requiresReconciliation && !steering.reconciliation && this._requestCarriesCurrentSteering(request, steering));
+    const maskSteeringTools = Boolean(this._currentSteeringReplyPending() || steering?.input.taskEpoch === this._taskEpoch && steering.gatesOldPlan && steering.requiresReconciliation && !steering.reconciliation && this._requestCarriesCurrentSteering(request, steering));
     const contracts = JSON.stringify([...this._canonicalToolExposureContracts]);
     let toolIntent = this._contextAdmissionToolIntents.get(request);
     if (toolIntent && (toolIntent.runId !== this._activeRunId || toolIntent.taskEpoch !== this._taskEpoch || toolIntent.contracts !== contracts || toolIntent.registry.some((entry) => this.tools.get(entry.name) !== entry.tool))) {
@@ -393525,6 +393726,15 @@ ${read.content}`;
         });
       }
     }
+    const argumentRepair = this._currentAdjudicationArgumentRepair(turn);
+    if (argumentRepair)
+      latest.set("adjudication-argument-repair", {
+        slot: "next_action",
+        source: "runtime.adjudication-argument-repair",
+        priority: 100,
+        protection: ["active_requirement"],
+        content: this._adjudicationArgumentRepairGuidance(argumentRepair)
+      });
     return [...latest.entries()].map(([id5, signal]) => ({
       id: `canonical-late:${id5}`,
       slot: signal.slot,
@@ -396739,6 +396949,52 @@ ${content}`)].join("\n\n");
   _hasUnresolvedCurrentSteeringInputs() {
     return this._nativeRequirementInterpretationHolds.size > 0 || this.pendingSteeringInputs.some((input) => (input.taskEpoch === void 0 || input.taskEpoch === this._taskEpoch) && (input.state === "received" || input.state === "queued" || input.state === "acknowledged" || input.state === "visible_in_request" || input.state === "reconciliation_required"));
   }
+  _currentSteeringReplyPending() {
+    const pending = this._pendingSteeringReply;
+    return pending && pending.runId === this.currentArtifactRunId() && pending.ownerId === this._interruptionOwnerId && pending.input.taskEpoch === this._taskEpoch && !["cancelled", "superseded", "consumed"].includes(pending.input.state) ? pending : null;
+  }
+  _adjudicationArgumentRepairIsCurrent(repair) {
+    const tool = this.lookupRegisteredTool(ADJUDICATION_TOOL_NAME)?.tool;
+    return repair.runId === this.currentArtifactRunId() && repair.taskEpoch === this._taskEpoch && repair.ownerId === this._interruptionOwnerId && repair.tool === tool && repair.schema === tool?.inputSchema && repair.parameters === JSON.stringify(tool?.parameters);
+  }
+  _currentAdjudicationArgumentRepair(turn) {
+    const repair = this._adjudicationArgumentRepair;
+    return repair && this._adjudicationArgumentRepairIsCurrent(repair) && (turn === void 0 || repair.settled && turn === repair.turn + 1) ? repair : null;
+  }
+  _adjudicationArgumentRepairGuidance(repair) {
+    return (repair.repeats ? "[ADJUDICATION_INVALID_REPLAY] Identical known-invalid arguments were refused without execution. Correct the named values before retrying.\n" : "") + formatAdjudicationArgumentRepair(repair.error, repair.contract.args_sha256);
+  }
+  _observePrimarySteeringReply(content, turn, emitMixedReply = false) {
+    const pending = this._currentSteeringReplyPending();
+    const visible = content ? partitionTypedModelOutput(content).visibleText.trim() : "";
+    let fence2;
+    const hasProse = visible.split(/\r?\n/).some((line) => {
+      const boundary2 = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
+      if (boundary2) {
+        if (!fence2)
+          fence2 = { marker: boundary2[1][0], length: boundary2[1].length };
+        else if (boundary2[1][0] === fence2.marker && boundary2[1].length >= fence2.length && !boundary2[2].trim())
+          fence2 = void 0;
+        return false;
+      }
+      return !fence2 && Boolean(line.trim());
+    });
+    const carried = Boolean(pending?.visibleRequestTurns.includes(turn));
+    const active = this._activeSteering;
+    if (emitMixedReply && hasProse && (carried || active?.input.taskEpoch === this._taskEpoch && active.requiresReconciliation && active.visibleRequestTurns.includes(turn))) {
+      this.emit({ type: "assistant_text", content: visible, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      this._assistantTextEmitted = true;
+    }
+    if (carried && hasProse) {
+      this._pendingSteeringReply = null;
+      this._steeringReplyTurn = {
+        runId: this.currentArtifactRunId(),
+        taskEpoch: this._taskEpoch,
+        ownerId: this._interruptionOwnerId,
+        turn
+      };
+    }
+  }
   _objectiveReadBatchAuxiliaryEligible() {
     const continuation = this._objectiveReadBatchContinuation;
     const batch = this.options.objectiveReadBatch;
@@ -396827,6 +397083,8 @@ ${content}`)].join("\n\n");
     const configuredPinnedBudget = this.options.virtualContext?.pinnedMemoryTokenBudget;
     const pinnedTokenBudget = Math.max(0, Math.min(physicalInputBudget, Number.isFinite(configuredPinnedBudget) && (configuredPinnedBudget ?? 0) > 0 ? Math.floor(configuredPinnedBudget) : adaptiveBudget.pinnedState));
     const pinnedMessages = this._pinnedStructuredMemoryMessages(pinnedTokenBudget, physicalInputBudget, turn);
+    if (this._currentAdjudicationArgumentRepair(turn) || this._currentSteeringReplyPending() || this._hasUnresolvedCurrentSteeringInputs())
+      return pinnedMessages;
     const residentInputTokens = estimateConservativeRequestInputTokens({
       messages: messages2.map((message) => ({ ...message })),
       tools,
@@ -396935,11 +397193,34 @@ ${content}`)].join("\n\n");
         }))
       ];
     }
+    const projectionRequest = {
+      controller: new AbortController(),
+      runId: this.currentArtifactRunId(),
+      taskEpoch: this._taskEpoch,
+      ownerId: this._interruptionOwnerId,
+      generation: this._modelRequestGeneration
+    };
+    this._virtualContextRequest = projectionRequest;
+    const signal = AbortSignal.any([
+      projectionRequest.controller.signal,
+      this._abortController.signal,
+      this._turnAbortController.signal,
+      this._inputWaitBoundaryController.signal
+    ]);
+    const isCurrent = () => !signal.aborted && this._virtualContextRequest === projectionRequest && projectionRequest.runId === this.currentArtifactRunId() && projectionRequest.taskEpoch === this._taskEpoch && projectionRequest.ownerId === this._interruptionOwnerId && projectionRequest.generation === this._modelRequestGeneration;
+    const assertCurrent = () => {
+      if (!isCurrent())
+        throw new InputWaitInterruption();
+    };
     try {
       const timeoutMs = this.options.requestTimeoutMs === 0 ? 0 : Number.isFinite(this.options.requestTimeoutMs) && (this.options.requestTimeoutMs ?? 0) > 0 ? this.options.requestTimeoutMs : 3e5;
-      const projection = await buildLiveVirtualContextProjection({
+      assertCurrent();
+      const projection = await withInputWaitCancellation(signal, () => buildLiveVirtualContextProjection({
         store,
-        archiveDocument: (document) => this._archiveVirtualEvidenceDocument(document),
+        archiveDocument: (document) => {
+          assertCurrent();
+          return this._archiveVirtualEvidenceDocument(document);
+        },
         ...this._structuredMemoryStore ? { memoryStore: this._structuredMemoryStore } : {},
         query,
         scopeId: this._sessionId,
@@ -396952,9 +397233,11 @@ ${content}`)].join("\n\n");
         auxiliaryContextWindowTokens: physicalWindow,
         auxiliaryMaxOutputTokens: this._explicitGenerationMaxTokens || this.options.maxTokens !== 16384 ? this._generationOutputCeiling() : void 0,
         maxRetrievalRounds: this.options.virtualContext?.maxRetrievalRounds,
-        signal: this._turnAbortController.signal,
+        signal,
         requestTimeoutMs: timeoutMs > 0 ? Math.min(timeoutMs, 3e4) : 3e4,
         onTrace: (event) => {
+          if (!isCurrent())
+            return;
           this._recordLiveVirtualContextTrace(event, turn);
           this.emit({
             type: "status",
@@ -396965,9 +397248,11 @@ ${content}`)].join("\n\n");
           });
         },
         infer: async (request) => {
+          assertCurrent();
           this._emitModelResolutionTelemetry(`virtual_memory_${request.stage}`, turn);
-          const response = await this._auxInferenceBackend({
-            dumpStage: `virtual_memory_${request.stage}`
+          const response = await withInputWaitCancellation(request.signal, () => this._auxInferenceBackend({
+            dumpStage: `virtual_memory_${request.stage}`,
+            assertCurrent
           }).chatCompletion({
             messages: [
               { role: "system", content: request.system },
@@ -396981,10 +397266,12 @@ ${content}`)].join("\n\n");
             think: false,
             workloadClass: this.options.workloadClass,
             logicalRequestId: this._modelTurnRequestId(turn, `virtual-memory:${request.stage}`)
-          });
+          }));
+          assertCurrent();
           return response.choices?.[0]?.message?.content ?? "";
         }
-      });
+      }));
+      assertCurrent();
       this._liveVirtualContextAttempt = { semanticKey, turn };
       if (!projection)
         return pinnedMessages;
@@ -397011,6 +397298,8 @@ ${content}`)].join("\n\n");
         }))
       ];
     } catch (error) {
+      if (!isCurrent() || error instanceof InputWaitInterruption)
+        return pinnedMessages;
       if (this._turnAbortController.signal.aborted)
         throw error;
       this._liveVirtualContextAttempt = { semanticKey, turn };
@@ -397022,6 +397311,9 @@ ${content}`)].join("\n\n");
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return pinnedMessages;
+    } finally {
+      if (this._virtualContextRequest === projectionRequest)
+        this._virtualContextRequest = null;
     }
   }
   _pinnedStructuredMemoryMessages(defaultTokenBudget, physicalInputBudget, turn) {
@@ -397816,7 +398108,7 @@ ${currentIntent.trim().slice(0, 6e3)}`,
             request: r
           });
         }
-        return this._dispatchInterruptionOwnedModelRequest(b, r, `model:aux:${opts?.dumpStage ?? "aux_inference"}`, { assertCurrent: opts?.assertCurrent });
+        return this._dispatchInterruptionOwnedModelRequest(b, r, `model:aux:${opts?.dumpStage ?? "aux_inference"}`, { assertCurrent: opts?.assertCurrent, signal: r.signal });
       }
     };
   }
@@ -400166,12 +400458,12 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
     if (!candidate)
       return { quality: "not_candidate", summary: "not a validation command" };
     if (!commandReliablySatisfiesVerifyCommand(command, command, result.executionReceipt)) {
-      const shape2 = describeUntrustedVerificationCommand(command, result.executionReceipt);
+      const shape3 = describeUntrustedVerificationCommand(command, result.executionReceipt);
       return {
         quality: "rejected_untrusted",
-        summary: `validation command is not receipt-authoritative: ${shape2}`,
-        reason: `Repair the execution shape: ${shape2}.`,
-        nextAction: `Run the canonical validation with a receipt-authoritative shape; current issue: ${shape2}.`
+        summary: `validation command is not receipt-authoritative: ${shape3}`,
+        reason: `Repair the execution shape: ${shape3}.`,
+        nextAction: `Run the canonical validation with a receipt-authoritative shape; current issue: ${shape3}.`
       };
     }
     if (result.success !== true) {
@@ -405802,7 +406094,16 @@ ${findingsBody}`;
     }
     return null;
   }
-  buildToolArgumentRepairFeedback(toolName, args, tool, validationError) {
+  buildToolArgumentRepairFeedback(toolName, args, tool, validationError, admittedRepair) {
+    if (tool.name === ADJUDICATION_TOOL_NAME) {
+      const argsKey = this._buildExactArgsKey(args);
+      const candidate = admittedRepair ?? this._currentAdjudicationArgumentRepair();
+      const repair = candidate && this._adjudicationArgumentRepairIsCurrent(candidate) && candidate.argsKey === argsKey ? candidate : null;
+      const guidance = repair ? this._adjudicationArgumentRepairGuidance(repair) : formatAdjudicationArgumentRepair(validationError, _createHash("sha256").update(argsKey).digest("hex"));
+      const message = `Invalid arguments for ${toolName}.
+${guidance}`;
+      return { error: message, llmContent: message, systemGuidance: guidance };
+    }
     const parameters = tool.parameters ?? {};
     const props = this.schemaProperties(parameters);
     const required = this.schemaRequired(parameters);
@@ -406002,28 +406303,12 @@ ${findingsBody}`;
     return corrected;
   }
   findSiblingToolSchemaMatches(requestedToolName, providedKeys) {
-    if (providedKeys.length === 0)
-      return [];
-    const provided = new Set(providedKeys);
-    const matches = [];
-    for (const candidate of this.tools.values()) {
-      if (candidate.name === requestedToolName)
-        continue;
-      const props = this.schemaProperties(candidate.parameters ?? {});
-      if (props.size === 0)
-        continue;
-      const required = this.schemaRequired(candidate.parameters ?? {});
-      const matched = providedKeys.filter((key) => props.has(key)).length;
-      if (matched === 0)
-        continue;
-      const requiredPresent = required.filter((key) => provided.has(key)).length;
-      const requiredSatisfied = required.length === 0 || requiredPresent === required.length;
-      const score = matched * 2 + requiredPresent * 3 + (requiredSatisfied ? 3 : 0) - Math.max(0, required.length - requiredPresent);
-      if (score >= 5 || matched >= 2 && requiredSatisfied) {
-        matches.push({ name: candidate.name, score });
-      }
-    }
-    return matches.sort((a, b) => b.score - a.score).slice(0, 3).map((match2) => match2.name);
+    return findBetterToolSchemaMatches({
+      requestedToolName,
+      requestedParameters: this.lookupRegisteredTool(requestedToolName)?.tool.parameters ?? {},
+      providedKeys,
+      candidates: this.tools.values()
+    });
   }
   unknownToolError(name) {
     const names = Array.from(this.tools.values()).map((tool) => tool.aliases?.length ? `${tool.name} (aliases: ${tool.aliases.join("|")})` : tool.name).sort();
@@ -406435,6 +406720,14 @@ ${notice}`;
       this._emitSteeringLifecycle(record9, !content ? "empty steering input rejected" : "replacement exceeds host intake authority");
       return this._steeringReceipt(record9);
     }
+    if ((record9.source === "tui-work-intake" || record9.source === "tui") && record9.intent !== "cancel") {
+      this._pendingSteeringReply = {
+        input: record9,
+        runId: this.currentArtifactRunId(),
+        ownerId: this._interruptionOwnerId,
+        visibleRequestTurns: []
+      };
+    }
     record9.state = "queued";
     this._emitSteeringLifecycle(record9, "queued for next safe turn boundary");
     if (steeringGatesOldPlan(record9.intent)) {
@@ -406444,6 +406737,13 @@ ${notice}`;
       this._requestSteeringPreemption(record9);
     }
     this._trajectoryDirtyCauses.add("user_steering");
+    const grounding = this._trajectoryGroundingRequest;
+    if (grounding?.runId === this.currentArtifactRunId() && grounding.taskEpoch === this._taskEpoch) {
+      grounding.controller.abort(new InputWaitInterruption());
+    }
+    const projection = this._virtualContextRequest;
+    if (projection?.runId === this.currentArtifactRunId() && projection.taskEpoch === this._taskEpoch && projection.ownerId === this._interruptionOwnerId)
+      projection.controller.abort(new InputWaitInterruption());
     return this._steeringReceipt(record9);
   }
   /**
@@ -407302,6 +407602,11 @@ The previous reviewer response failed exact candidate-quote serialization. Host
       this._pendingSteeringPreemption = null;
     }
     this._emitSteeringLifecycle(record9, "retracted before admission at a safe boundary");
+    if (this._activeSteering) {
+      this._activeSteering.relatedInputs = this._activeSteering.relatedInputs?.filter((input) => input !== record9);
+      if (this._activeSteering.input === record9 && !this._activeSteering.relatedInputs?.length)
+        this._activeSteering = null;
+    }
     return record9.content;
   }
   /** Abort the current task run through the generation-bound stop lineage. */
@@ -408769,7 +409074,7 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
     if (!active)
       return null;
     const { input, reconciliation } = active;
-    if (isSteeringScopeResolved(active))
+    if (isSteeringScopeResolved(active) && !this._currentSteeringReplyPending())
       return null;
     const sources = [input, ...active.relatedInputs ?? []];
     const exactSourcesPresent = this.effectiveContextWindow() > 0 && this.effectiveContextWindow() <= 8192 && input.taskEpoch === this._taskEpoch && sources.every((source) => source.taskEpoch === this._taskEpoch && source.state !== "cancelled" && source.state !== "superseded" && sourceMessages?.some((message) => message.role === "user" && message.content === source.content && message.requiredSourceEvidence?.schema === "omnius.required-source-evidence.v1" && message.requiredSourceEvidence.scope === this._steeringAuthorityScope(source)));
@@ -408782,6 +409087,8 @@ issuer=${predecessor.runId}; evidence=${receipt.id}; raw_ref=${receipt.rawRef ??
       `kind=${input.intent}`,
       `admission=${active.gatesOldPlan ? "old_plan_gated" : "context_active"}`,
       "This is current user authority, not historical transcript context.",
+      "Answer the latest user's question or briefly state the concrete effect of their change first, in ordinary visible prose. Then reconcile the current instruction internally before deeper planning or tools. Do not announce steering, reconciliation, or internal reviews.",
+      isSteeringScopeResolved(active) && this._currentSteeringReplyPending() ? "The internal scope decision is already stored. Give the actual user-facing answer now; do not repeat the internal reconciliation, call tools, or replace the original objective." : null,
       input.intent === "redirect" || input.intent === "replace" ? "The prior task epoch is historical evidence only. Do not continue its plan, todos, recovery cards, or completion contract." : null,
       needsClarification ? "You requested clarification. Do not call tools or resume the old plan; ask the user one concise question." : active.requiresReconciliation ? [
         renderSteeringReconciliationProtocol(input.inputId),
@@ -408807,9 +409114,13 @@ ${exactSourcesPresent ? exactSourcePointer(related) : related.content}`),
   }
   _markActiveSteeringVisible(turn) {
     const active = this._activeSteering;
-    if (!active || isSteeringScopeResolved(active) || active.visibleRequestTurns.includes(turn))
+    const pendingReply = this._currentSteeringReplyPending();
+    if (pendingReply && active && [active.input, ...active.relatedInputs ?? []].includes(pendingReply.input) && !pendingReply.visibleRequestTurns.includes(turn))
+      pendingReply.visibleRequestTurns.push(turn);
+    if (!active || isSteeringScopeResolved(active) || active.visibleRequestTurns.includes(turn) && ![active.input, ...active.relatedInputs ?? []].some((input) => input.state === "queued" || input.state === "acknowledged"))
       return;
-    active.visibleRequestTurns.push(turn);
+    if (!active.visibleRequestTurns.includes(turn))
+      active.visibleRequestTurns.push(turn);
     for (const input of [active.input, ...active.relatedInputs ?? []]) {
       input.state = "visible_in_request";
       this._emitSteeringLifecycle(input, `visible in model request at turn ${turn}`);
@@ -408953,6 +409264,11 @@ ${exactSourcesPresent ? exactSourcePointer(related) : related.content}`),
     if (this.taskRequirementInterpretationPending)
       return "native_requirement_interpretation_pending: the host is reviewing the latest authenticated human instruction; no new action or completion is admitted until its canonical requirements are durably resolved.";
     const active = this._activeSteering;
+    const replyTurn = this._steeringReplyTurn;
+    if (replyTurn?.runId === this.currentArtifactRunId() && replyTurn.taskEpoch === this._taskEpoch && replyTurn.ownerId === this._interruptionOwnerId && replyTurn.turn === turn)
+      return "[HUMAN_RESPONSE_TURN_REQUIRED] The current response answers the user. Wait for the next model decision before executing tools.";
+    if (this._currentSteeringReplyPending() && (!active || isSteeringScopeResolved(active)))
+      return "[HUMAN_RESPONSE_REQUIRED] Answer the current user's question or change briefly in visible prose before further tools or planning. Its internal scope decision is already stored.";
     if (!active)
       return null;
     if (active.input.taskEpoch === this._taskEpoch && active.reconciliation && active.reconciliation.status !== "needs_clarification" && active.reconciledTurn === turn) {
@@ -408973,7 +409289,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
       return [
         `[STEERING_RECONCILIATION_REQUIRED]
 input_id=${active.input.inputId}`,
-        "Do not execute the old-plan tool call. Emit the steering reconciliation first, as text in your very next response, with no tool calls in that response.",
+        "Do not execute the old-plan tool call. Answer the current user briefly in visible prose first, then emit the internal steering reconciliation, with no tool calls in that response.",
         priorRefusals > 0 ? `You have already been refused this exact call ${priorRefusals} time(s). Repeating it will keep being refused. Emit the reconciliation now, or take a different concrete action.` : null,
         renderSteeringReconciliationProtocol(active.input.inputId)
       ].filter(Boolean).join("\n");
@@ -409011,7 +409327,7 @@ Only the exact pending declared read tickets may execute. Old-plan mutations and
         authoritySlot: "[ACTIVE USER STEERING]",
         priorRefusals
       }),
-      "Do not execute or retry old-plan tools. Emit [STEERING_RECONCILIATION] as your next response text with no tool calls; follow the complete protocol and user instruction in [ACTIVE USER STEERING]."
+      "Do not execute or retry old-plan tools. Answer the current user briefly in visible prose, then emit [STEERING_RECONCILIATION] with no tool calls; follow the complete protocol and user instruction in [ACTIVE USER STEERING]."
     ].join("\n");
   }
   _markFirstSteeringAffectedAction(toolName, turn) {
@@ -411269,6 +411585,8 @@ ${rawTask}`;
     if (this.options.trajectoryCheckpoint === "shadow" || this.options.trajectoryGrounding === "off") {
       return null;
     }
+    if (this._hasUnresolvedCurrentSteeringInputs() || this._currentSteeringReplyPending() || this._currentAdjudicationArgumentRepair(turn))
+      return null;
     const { id: _id, revision: _revision, turn: _turn, ...base } = checkpoint;
     const semanticKey = this._loopRecoveryAdvisoryKey();
     const baseFingerprint = `${trajectoryCheckpointFingerprint(base)}:${semanticKey}`;
@@ -411344,12 +411662,29 @@ ${rawTask}`;
     this._trajectoryGroundingAttemptedFingerprint = baseFingerprint;
     this._trajectoryGroundingMaterial = materialFingerprint;
     const review = this._beginRecoveryReview("trajectory");
+    const grounding = { controller: new AbortController(), runId: this.currentArtifactRunId(), taskEpoch: this._taskEpoch };
+    this._trajectoryGroundingRequest = grounding;
+    const signal = AbortSignal.any([
+      grounding.controller.signal,
+      this._abortController.signal,
+      this._turnAbortController.signal,
+      this._inputWaitBoundaryController.signal
+    ]);
+    const owner = this._interruptionOwnerId;
+    const requestGeneration = this._modelRequestGeneration;
+    const assertCurrent = () => {
+      signal.throwIfAborted();
+      if (grounding.runId !== this.currentArtifactRunId() || grounding.taskEpoch !== this._taskEpoch || owner !== this._interruptionOwnerId || requestGeneration !== this._modelRequestGeneration || !this._recoveryReviewIsCurrent(review) || this._hasUnresolvedCurrentSteeringInputs())
+        throw new InputWaitInterruption();
+    };
     try {
+      assertCurrent();
       this._emitModelResolutionTelemetry("trajectory_grounding", turn);
       const backend = this._auxInferenceBackend({
-        dumpStage: "trajectory_grounding"
+        dumpStage: "trajectory_grounding",
+        assertCurrent
       });
-      const response = await backend.chatCompletion({
+      const response = await withInputWaitCancellation(signal, () => backend.chatCompletion({
         messages: [
           {
             role: "system",
@@ -411368,8 +411703,10 @@ ${rawTask}`;
         timeoutMs: this.options.requestTimeoutMs,
         // The output is an explicit concise assessment, not a hidden-think
         // transcript. Keep Qwen's structured response path reliable.
-        think: false
-      });
+        think: false,
+        signal
+      }));
+      assertCurrent();
       const generated = parseTrajectoryGeneratedGrounding(response.choices?.[0]?.message?.content ?? "", checkpoint.groundedFacts.map((fact) => fact.evidence));
       if (!this._recoveryReviewIsCurrent(review))
         return null;
@@ -411425,7 +411762,9 @@ ${rawTask}`;
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return generated;
-    } catch {
+    } catch (error) {
+      if (signal.aborted || error instanceof InputWaitInterruption || !this._recoveryReviewIsCurrent(review))
+        return null;
       this.emit({
         type: "status",
         content: "Trajectory grounding unavailable; retaining deterministic safety orientation",
@@ -411433,6 +411772,9 @@ ${rawTask}`;
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return null;
+    } finally {
+      if (this._trajectoryGroundingRequest === grounding)
+        this._trajectoryGroundingRequest = null;
     }
   }
   /**
@@ -413875,12 +414217,16 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
     };
     const preparedToolArguments = /* @__PURE__ */ new WeakMap();
     const originalToolArguments = /* @__PURE__ */ new WeakMap();
+    const preparedAdjudicationRepairs = /* @__PURE__ */ new WeakMap();
     const prepareToolArguments = async (tc, toolTurn) => {
       if (preparedToolArguments.has(tc))
         return preparedToolArguments.get(tc);
       originalToolArguments.set(tc, structuredClone(tc.arguments ?? {}));
+      const preparationScope = { runId: this.currentArtifactRunId(), taskEpoch: this._taskEpoch, ownerId: this._interruptionOwnerId };
+      const preparationIsCurrent = () => preparationScope.runId === this.currentArtifactRunId() && preparationScope.taskEpoch === this._taskEpoch && preparationScope.ownerId === this._interruptionOwnerId;
       const resolved = this.lookupRegisteredTool(tc.name);
       let error = null;
+      let adjudicationArgs;
       if (resolved && !(tc.arguments && "_raw" in tc.arguments)) {
         try {
           const workflow = extractFeatureWorkflowToolBinding(tc.arguments ?? {});
@@ -413894,6 +414240,18 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             args = this._autoDeriveDelegationMutationScope(resolved.name, args, toolTurn);
             args = await this._enrichDelegationToolArgs(resolved.name, args, messages2, toolTurn);
           }
+          if (resolved.name === ADJUDICATION_TOOL_NAME) {
+            adjudicationArgs = args;
+            tc.arguments = args;
+            const prior = preparationIsCurrent() ? this._currentAdjudicationArgumentRepair() : null;
+            if (prior?.argsKey === this._buildExactArgsKey(args)) {
+              const replay = { ...prior, turn: toolTurn, repeats: prior.repeats + 1, settled: false };
+              preparedAdjudicationRepairs.set(tc, replay);
+              this._adjudicationArgumentRepair = replay;
+              preparedToolArguments.set(tc, prior.error);
+              return prior.error;
+            }
+          }
           if (resolved.tool.inputSchema)
             args = this._parsedToolArgumentRecord(resolved.tool.inputSchema.parse(args));
           else {
@@ -413906,6 +414264,22 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             this._featureWorkflowBindings.set(args, workflow.cardId);
         } catch (caught) {
           error = caught instanceof Error ? caught.message : String(caught);
+          if (resolved.name === ADJUDICATION_TOOL_NAME && adjudicationArgs && preparationIsCurrent()) {
+            const repair = {
+              ...preparationScope,
+              tool: resolved.tool,
+              schema: resolved.tool.inputSchema,
+              parameters: JSON.stringify(resolved.tool.parameters),
+              argsKey: this._buildExactArgsKey(adjudicationArgs),
+              contract: adjudicationArgumentRepairContract(error, _createHash("sha256").update(this._buildExactArgsKey(adjudicationArgs)).digest("hex")),
+              error,
+              turn: toolTurn,
+              repeats: 0,
+              settled: false
+            };
+            preparedAdjudicationRepairs.set(tc, repair);
+            this._adjudicationArgumentRepair = repair;
+          }
         }
       }
       preparedToolArguments.set(tc, error);
@@ -414891,7 +415265,8 @@ ${cachedResult}`,
         if (resolvedTool && !this._isToolExposedForModelCall(resolvedTool.name) && !this._admitDeferredDirectCall(resolvedTool.name, turn)) {
           result = this._missingCapabilityResult(resolvedTool.name, turn);
         } else if (preparedArgumentError && tool) {
-          const repair = this.buildToolArgumentRepairFeedback(tc.name, tc.arguments, tool, preparedArgumentError);
+          const admittedRepair = preparedAdjudicationRepairs.get(tc);
+          const repair = this.buildToolArgumentRepairFeedback(tc.name, tc.arguments, tool, preparedArgumentError, admittedRepair);
           runtimeSystemGuidance = repair.systemGuidance;
           result = {
             success: false,
@@ -414900,6 +415275,21 @@ ${cachedResult}`,
             llmContent: repair.llmContent,
             runtimeAuthored: true
           };
+          const argumentRepair = admittedRepair && this._adjudicationArgumentRepairIsCurrent(admittedRepair) && admittedRepair.argsKey === this._buildExactArgsKey(tc.arguments) ? admittedRepair : null;
+          if (argumentRepair) {
+            argumentRepair.settled = true;
+            this._adjudicationArgumentRepair = argumentRepair;
+            result.data = { kind: "adjudication_argument_repair", contract: argumentRepair.contract };
+            result.failure = { kind: "schema_validation", field: argumentRepair.contract.fields[0]?.path };
+            result.failureDiagnosis = {
+              ...classifyRuntimeFailure({ toolName: resolvedTool.name, failure: result.failure, errorText: repair.error }),
+              retryable: false,
+              createRecoveryCard: false,
+              guidance: repair.systemGuidance
+            };
+            if (argumentRepair.repeats)
+              repeatShortCircuit = result;
+          }
         } else if (repeatShortCircuit) {
           result = repeatShortCircuit;
         } else if (tc.arguments && "_raw" in tc.arguments) {
@@ -416484,6 +416874,8 @@ ${bookkeepingGuidance}` : bookkeepingGuidance;
         }
         if (result.success) {
           delete result.failureDiagnosis;
+          if (result.runtimeAuthored !== true && this._currentAdjudicationArgumentRepair()?.settled)
+            this._adjudicationArgumentRepair = null;
         } else if (!processWasStopped && !completionReviewIsPending && !this._isPdfTerminalFeedback(result)) {
           this._diagnoseToolFailure(tc.name, tc.arguments, result);
           const staleHashRetryGuidance = this._buildStaleHashRetryGuidance(tc.name, tc.arguments, result);
@@ -418850,7 +419242,12 @@ ${memoryLines.join("\n")}`
       }
       const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
       this.gcSystemMessages(requestMessages2);
+      const steeringBeforeVirtualContext = new Set(this.pendingSteeringInputs);
       const virtualEvidenceMessages = await this._buildLiveVirtualContextMessages(task, requestMessages2, turn, toolDefs);
+      if (this.pendingSteeringInputs.some((input) => !steeringBeforeVirtualContext.has(input) && !["cancelled", "superseded", "consumed"].includes(input.state))) {
+        --localTurn;
+        continue;
+      }
       if (virtualEvidenceMessages.length > 0) {
         const insertionIndex = requestMessages2[0]?.role === "system" ? 1 : 0;
         requestMessages2.splice(insertionIndex, 0, ...virtualEvidenceMessages);
@@ -419423,6 +419820,7 @@ ${transportFailure2}` : transportFailure2;
       if (!choice)
         break;
       const msg = choice.message;
+      this._observePrimarySteeringReply(response["_rawTypedModelContent"] ?? msg.content, turn, !this.options.streamEnabled && Boolean(msg.toolCalls?.length));
       this._reconcileActiveSteeringFromModel(response["_rawTypedModelContent"] ?? msg.content, turn, messages2);
       if (this._preparedTaskScopeBoundary && this._pendingSteeringPreemption) {
         await this._applySteeringAtSafeBoundary(messages2, turn);
@@ -420457,7 +420855,12 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
         }
         this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
         this.gcSystemMessages(compactedMsgs);
+        const steeringBeforeVirtualContext = new Set(this.pendingSteeringInputs);
         const virtualEvidenceMessages = await this._buildLiveVirtualContextMessages(persistentTaskGoal, compactedMsgs, turn, toolDefs);
+        if (this.pendingSteeringInputs.some((input) => !steeringBeforeVirtualContext.has(input) && !["cancelled", "superseded", "consumed"].includes(input.state))) {
+          --localTurn;
+          continue;
+        }
         const bfRequestMessages = compactedMsgs.map((message) => ({
           ...message
         }));
@@ -420777,6 +421180,7 @@ ${diagnosis}` : diagnosis;
         if (!choice)
           break;
         const msg = choice.message;
+        this._observePrimarySteeringReply(response["_rawTypedModelContent"] ?? msg.content, turn, !this.options.streamEnabled && Boolean(msg.toolCalls?.length));
         this._reconcileActiveSteeringFromModel(response["_rawTypedModelContent"] ?? msg.content, turn, messages2);
         if (this._preparedTaskScopeBoundary && this._pendingSteeringPreemption) {
           await this._applySteeringAtSafeBoundary(messages2, turn);
@@ -429166,6 +429570,9 @@ var OllamaAgenticBackend = class _OllamaAgenticBackend {
       if (enabledGpuUuids !== void 0) {
         headers["X-Ollama-Unify-GPU-UUIDs"] = enabledGpuUuids.length > 0 ? enabledGpuUuids.join(",") : "none";
       }
+      if (cpuOffloadAllowedFromEnv()) {
+        headers["X-Ollama-Unify-CPU-Offload"] = "allow";
+      }
       const envOverride = process.env["OMNIUS_OLLAMA_BROKER_ADMISSION_WAIT_MS"];
       const classDefault = workloadClass === "background" ? 500 : workloadClass === "interactive-control" ? 3e4 : void 0;
       const configured = Number.parseInt(String(request?.brokerAdmissionWaitMs ?? envOverride ?? classDefault ?? 0), 10);
@@ -430321,114 +430728,6 @@ init_dist3();
 init_ollama_pool();
 init_ollama_pool_cleanup();
 
-// packages/orchestrator/dist/adjudication.js
-import { z as z25 } from "zod";
-var IdSchema = z25.string().trim().min(1).max(96).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "use a stable identifier without whitespace");
-var AdjudicationEvidenceSchema = z25.object({
-  id: IdSchema,
-  content: z25.string().trim().min(1).max(32e3),
-  source: z25.string().trim().min(1).max(500),
-  kind: z25.enum([
-    "fact",
-    "observation",
-    "artifact",
-    "test_result",
-    "testimony",
-    "constraint",
-    "precedent"
-  ]).default("observation"),
-  observedAt: z25.string().trim().max(80).optional(),
-  sha256: z25.string().trim().regex(/^[a-fA-F0-9]{64}$/).optional(),
-  reliability: z25.number().min(0).max(1).optional()
-});
-var AdjudicationArgumentSchema = z25.object({
-  id: IdSchema,
-  position: z25.string().trim().min(1).max(160),
-  claim: z25.string().trim().min(1).max(4e3),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(64),
-  submittedBy: z25.string().trim().max(160).optional()
-});
-var AdjudicationConstituentInputSchema = z25.object({
-  id: IdSchema.optional(),
-  label: z25.string().trim().min(1).max(120),
-  question: z25.string().trim().min(1).max(2e3),
-  instructions: z25.string().trim().max(2e3).optional(),
-  evidenceIds: z25.array(IdSchema).min(1).max(128).optional(),
-  argumentIds: z25.array(IdSchema).max(64).optional(),
-  decisionRuleIds: z25.array(IdSchema).max(32).optional()
-});
-var AdjudicationInputSchema = z25.object({
-  caseId: IdSchema.optional(),
-  question: z25.string().trim().min(1).max(4e3),
-  context: z25.string().trim().max(8e3).optional(),
-  exclusions: z25.array(z25.string().trim().min(1).max(2e3)).max(32).default([]),
-  allowedOutcomes: z25.array(IdSchema).min(2).max(12),
-  decisionRules: z25.array(z25.string().trim().min(1).max(2e3)).max(24).default([]),
-  burdenOfProof: z25.enum([
-    "best_supported",
-    "preponderance",
-    "clear_and_convincing",
-    "beyond_reasonable_doubt",
-    "risk_averse"
-  ]).default("best_supported"),
-  evidence: z25.array(AdjudicationEvidenceSchema).min(1).max(128),
-  arguments: z25.array(AdjudicationArgumentSchema).max(64).default([]),
-  constituents: z25.array(AdjudicationConstituentInputSchema).min(2).max(6).optional(),
-  panelSize: z25.number().int().min(2).max(6).default(3),
-  maxConcurrency: z25.number().int().min(1).max(6).default(3),
-  quorum: z25.number().int().min(2).max(6).optional(),
-  constituentExecution: z25.enum(["auto", "full_sub_agent", "direct"]).default("auto"),
-  timeoutMs: z25.number().int().min(5e3).max(6e5).default(12e4),
-  maxTokensPerConstituent: z25.number().int().min(512).max(8192).default(2048),
-  maxJudgeTokens: z25.number().int().min(768).max(12288).default(3072)
-});
-var PlannerResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  assignments: z25.array(z25.object({
-    id: IdSchema,
-    label: z25.string().trim().min(1).max(120),
-    question: z25.string().trim().min(1).max(2e3),
-    instructions: z25.string().trim().max(2e3).default(""),
-    evidenceIds: z25.array(IdSchema).min(1).max(128),
-    argumentIds: z25.array(IdSchema).max(64).default([]),
-    decisionRuleIds: z25.array(IdSchema).min(1).max(32)
-  })).min(2).max(6)
-});
-var ConstituentResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  constituentId: IdSchema,
-  assessment: z25.string().trim().min(20).max(8e3),
-  recommendation: IdSchema,
-  confidence: z25.number().min(0).max(1),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(128),
-  claims: z25.array(z25.object({
-    claim: z25.string().trim().min(1).max(2e3),
-    evidenceIds: z25.array(IdSchema).min(1).max(64)
-  })).min(1).max(24),
-  counterarguments: z25.array(z25.string().trim().min(1).max(2e3)).max(16).default([]),
-  uncertainties: z25.array(z25.string().trim().min(1).max(2e3)).max(16).default([])
-});
-var JudgeResponseSchema = z25.object({
-  schemaVersion: z25.literal(1),
-  caseId: IdSchema,
-  verdict: IdSchema,
-  confidence: z25.number().min(0).max(1),
-  rationale: z25.string().trim().min(30).max(12e3),
-  citedEvidenceIds: z25.array(IdSchema).min(1).max(128),
-  consideredConstituentIds: z25.array(IdSchema).min(2).max(6),
-  acceptedFindingIds: z25.array(IdSchema).max(144),
-  rejectedFindingIds: z25.array(IdSchema).max(144),
-  dissent: z25.array(z25.object({
-    constituentId: IdSchema,
-    recommendation: IdSchema,
-    summary: z25.string().trim().min(1).max(2e3)
-  })).max(6).default([]),
-  unresolvedQuestions: z25.array(z25.string().trim().min(1).max(2e3)).max(24).default([]),
-  nextAction: z25.string().trim().min(1).max(4e3)
-});
-
 // packages/orchestrator/dist/agent-types.js
 var READ_ONLY_TOOLS = [
   "file_read",