@awak-app/simy-cli 0.7.28 → 0.7.31

package/src/native-development-report-completion.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { effectiveAcceptanceCriteria } from "./codex-plugins/simy/hooks/acceptance-policy.mjs";
 
 import {
   NATIVE_DEVELOPMENT_REPORT_COMPLETIONS_PATH,
@@ -141,3 +142,28 @@ function canonicalJson(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
 }
+
+// v2: completion is a machine-observed controller outcome, not a request for
+// human certification or a particular acceptance-document format. This never
+// promotes provider reported_done or process exit to completed.
+export function projectControllerCompletion(record) {
+  const run = record?.run;
+  const acceptance = run?.managed?.acceptanceCriteria;
+  if (acceptance !== undefined && (!Array.isArray(acceptance) ||
+      acceptance.some(criterion => !criterion || typeof criterion !== 'object' || Array.isArray(criterion)))) return null;
+  if (effectiveAcceptanceCriteria(run?.managed).some(criterion => criterion.check?.type === 'manual' &&
+      !projectCriterion(criterion, run.managed.verified, run.managed.criterionObservations, 0))) return null;
+  const taskId = run?.managed?.taskId || run?.id;
+  if (run?.managed?.thread && (run.managed.thread.provider !== record.provider || run.managed.thread.id !== record.session)) return null;
+  const recordedChecks = Object.values(run?.managed?.verified || {}).map(item => typeof item.checkedAt === 'number' ? item.checkedAt : Date.parse(item.checkedAt)).filter(Number.isFinite);
+  const checkedAt = normalizeIso(run?.completedAt ?? run?.updatedAt ?? run?.checkpoint?.at ?? (recordedChecks.length ? Math.max(...recordedChecks) : undefined));
+  if (!['codex', 'claude'].includes(record?.provider) || !UUID.test(record?.session || '') ||
+      run?.state !== 'completed' || run?.checkpoint?.status !== 'completed' ||
+      run?.recoveryCause === 'process_exit' || !UUID.test(taskId || '') || !checkedAt ||
+      !Number.isSafeInteger(run.revision) || run.revision < 0) return null;
+  const criteria = [{ id_hash: digest('controller-outcome'), source: 'controller_result', checked_at: checkedAt,
+    evidence_digest: digest({ taskId, revision: run.revision, checkpoint: run.checkpoint }) }];
+  return { provider: record.provider, provider_session_id: record.session.toLowerCase(), task_id: taskId.toLowerCase(),
+    managed_revision: run.revision, checkpoint_digest: digest(run.checkpoint), acceptance_digest: digest(criteria),
+    verified_at: checkedAt, criteria };
+}

package/src/native-development-reports.js

@@ -18,14 +18,16 @@ export class NativeDevelopmentReportsError extends Error {
 
 export function normalizeNativeDevelopmentReportEnrollment(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidResponse();
-  const keys = Object.keys(value).sort();
+  const keys = Object.keys(value).filter(key => key !== 'host_id').sort();
   const expected = ["enabled", "provider", "provider_session_id", "request_title", "revision"];
   if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) throw invalidResponse();
   if (!PROVIDERS.has(value.provider) || !UUID.test(value.provider_session_id) ||
       typeof value.request_title !== "string" || value.request_title.length > 160 || CONTROL.test(value.request_title) ||
       typeof value.enabled !== "boolean" || !Number.isSafeInteger(value.revision) || value.revision < 0 ||
       (value.enabled && value.revision === 0)) throw invalidResponse();
+  if (value.host_id !== undefined && (typeof value.host_id !== 'string' || !/^(local|remote-ssh-discovered:[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127})$/.test(value.host_id))) throw invalidResponse();
   return Object.freeze({
+    ...(value.host_id !== undefined ? { host_id: value.host_id } : {}),
     provider: value.provider,
     provider_session_id: value.provider_session_id.toLowerCase(),
     request_title: value.request_title,
@@ -36,7 +38,7 @@ export function normalizeNativeDevelopmentReportEnrollment(value) {
 
 export function normalizeNativeDevelopmentReportSave(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new NativeDevelopmentReportsError("Invalid development report request.", { code: "invalid_native_development_report_request" });
-  const keys = Object.keys(value).sort();
+  const keys = Object.keys(value).filter(key => key !== 'host_id').sort();
   const expected = ["enabled", "expected_revision", "provider", "provider_session_id", "request_title"];
   if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) throw new NativeDevelopmentReportsError("Invalid development report request.", { code: "invalid_native_development_report_request" });
   if (!PROVIDERS.has(value.provider) || !UUID.test(value.provider_session_id) || typeof value.enabled !== "boolean" ||
@@ -46,7 +48,9 @@ export function normalizeNativeDevelopmentReportSave(value) {
   if (requestTitle.length > 160 || CONTROL.test(requestTitle) || (value.enabled && requestTitle.length === 0)) {
     throw new NativeDevelopmentReportsError("Invalid development report title.", { code: "invalid_native_development_report_request" });
   }
+  if (value.host_id !== undefined && (typeof value.host_id !== 'string' || !/^(local|remote-ssh-discovered:[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127})$/.test(value.host_id))) throw invalidResponse();
   return Object.freeze({
+    ...(value.host_id !== undefined ? { host_id: value.host_id } : {}),
     provider: value.provider,
     provider_session_id: value.provider_session_id.toLowerCase(),
     request_title: requestTitle,
@@ -90,11 +94,17 @@ export function createNativeDevelopmentReportsApi({ webOrigin, readSession, fetc
     const session = await sessionForRequest();
     let response;
     try {
-      response = await fetchImpl(webApiUrl(path, {
+      const url = webApiUrl(path, {
         webOrigin, apiBaseUrl: session.api_base_url,
-      }), {
+      });
+      // Older dev gateways forward the query but omit protocol headers. Keep
+      // negotiation explicit without requiring a production gateway rollout.
+      if (url.pathname.startsWith('/api/local-cli-gateway/')) {
+        url.searchParams.set('native_report_version', '2');
+      }
+      response = await fetchImpl(url, {
         method,
-        headers: webApiHeaders({ token: session.token }, body === undefined ? {} : { "Content-Type": "application/json" }),
+        headers: webApiHeaders({ token: session.token }, { "x-simy-native-report-version": "2", ...(body === undefined ? {} : { "Content-Type": "application/json" }) }),
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: AbortSignal.timeout(10_000),
         cache: "no-store",

package/src/orchestrator/budget.js

@@ -1,3 +1,4 @@
+import { completeProviderUsage, extractProviderTokenUsage } from '../provider-stream.js';
 import { clampAttempts } from "./shared.js";
 import { progressLimits } from "../continuation-policy.js";
 
@@ -94,6 +95,9 @@ export function budgetState(snapshot, pendingAttempt = null) {
     (sum, attempt) => sum + tokenUsageTotal(attempt?.token_usage),
     0,
   ) + unaccountedProviderUsage(snapshot, attempts);
+  const usageUnknown = Object.values(snapshot?.metadata?.provider_usage_checkpoints || {}).some(
+    checkpoint => ['pending', 'unknown'].includes(checkpoint?.usage_status),
+  );
   const attemptsUsed = attempts.length;
   const retriesUsed = Math.max(attemptsUsed - 1, 0);
   const policy = progressLimits(snapshot?.charter);
@@ -108,6 +112,7 @@ export function budgetState(snapshot, pendingAttempt = null) {
     schema_version: 1,
     token_budget: tokenBudget,
     tokens_used: tokensUsed,
+    usage_unknown: usageUnknown,
     tokens_remaining: Math.max(tokenBudget - tokensUsed, 0),
     token_exhausted: tokenExhausted,
     retry_budget: retryBudget,
@@ -148,8 +153,27 @@ export function refreshBudgetState(snapshot, pendingAttempt = null) {
   return state;
 }
 
+// Re-read only host-persisted output from the same native invocation. Missing
+// receipts stay unknown; a new call or an estimate cannot clear this hold.
+export function reconcileProviderUsage(snapshot) {
+  for (const [id, checkpoint] of Object.entries(snapshot?.metadata?.provider_usage_checkpoints || {})) {
+    if (!['pending', 'unknown'].includes(checkpoint?.usage_status) || checkpoint.invocation_id !== id || !['claude', 'codex'].includes(checkpoint.backend)) continue;
+    const results = Object.values(snapshot.metadata.dispatch_results || {}).filter(result => result?.invocationId === id);
+    if (results.length !== 1 || results[0].result_parse?.channel !== 'provider_final') continue;
+    const events = (results[0].logs || []).flatMap(line => {
+      try { const event = JSON.parse(line); return checkpoint.backend === 'claude' ? event.type === 'result' ? [event] : [] : event.type === 'turn.completed' ? [event] : []; } catch { return []; }
+    });
+    if (!events.length || checkpoint.backend === 'claude' && events.length !== 1 || events.some(event => !completeProviderUsage(checkpoint.backend, event))) continue;
+    checkpoint.token_usage = { records: events.map(event => ({ ...extractProviderTokenUsage(checkpoint.backend, event),
+      invocation_id: id, phase: checkpoint.phase, backend: checkpoint.backend })) };
+    checkpoint.usage_status = 'observed';
+  }
+}
+
 export function canStartProvider(snapshot, { attemptNumber, phase = "executor" } = {}) {
+  reconcileProviderUsage(snapshot);
   const budget = refreshBudgetState(snapshot);
+  if (budget.usage_unknown) return { allowed: false, reason: 'provider_usage_unknown', budget };
   if (budget.token_exhausted) {
     return { allowed: false, reason: "provider_token_ceiling_reached", budget };
   }

package/src/orchestrator/charter-repair.js

@@ -58,7 +58,7 @@ export async function repairCharterWithAI({ snapshot, execute, shouldStop = () =
       const execution = await execute({ phase, backend: charter.audit_backend, charter: structuredClone(charter), instruction, ...extra });
       const id = execution?.invocationId || `${round.id}:${phase}`;
       snapshot.metadata.provider_usage_checkpoints ??= {};
-      snapshot.metadata.provider_usage_checkpoints[id] = { invocation_id: id, phase: 'reviewer', token_usage: execution?.tokenUsage || {} };
+      snapshot.metadata.provider_usage_checkpoints[id] = { invocation_id: id, phase: 'reviewer', token_usage: execution?.tokenUsage || {}, ...snapshot.metadata.provider_usage_checkpoints[id] };
       await onUpdate(snapshot);
       if (shouldStop()) throw new Error('Charter repair stopped.');
       return execution;

package/src/orchestrator/completion-contract.js

@@ -135,6 +135,10 @@ export function completionEvidenceChecks(charter, attempt) {
 
   const rows = acceptanceCriterionRows(charter);
   const criterionEvidence = normalizeCriterionEvidence(attempt?.criterion_evidence);
+  const outcome = attempt?.completion_result || attempt?.raw_output?.completion_result;
+  // The worker can describe its actual end-to-end check once. Dedicated rows
+  // are optional; a concrete failed row always defeats a broad success claim.
+  const wholeOutcome = hasUserOutcomeProof({ user_outcome: outcome });
   const known = new Set(rows.map(row => row.id));
   const checks = [check("criterion_evidence_scope", "Results belong to the requested behavior",
     criterionEvidence.every(row => known.has(row.criterion_id)), "Do not substitute an unrelated result for the request.")];
@@ -147,7 +151,7 @@ export function completionEvidenceChecks(charter, attempt) {
         `criterion_evidence_${row.id.toLowerCase()}`,
         `${row.id} has passing completion evidence`,
         Boolean(
-          matches.length === 1 &&
+          matches.length === 0 ? wholeOutcome : matches.length === 1 &&
             evidence?.passed &&
             evidence.verification_method &&
             evidence.observed_result,
@@ -158,7 +162,9 @@ export function completionEvidenceChecks(charter, attempt) {
           ? `${evidence.verification_method || "method missing"}: ${
               evidence.observed_result || "observed result missing"
             }; evidence ${evidence.evidence_refs.join(", ") || "missing"}.`
-          : `No criterion evidence was recorded for ${row.id}: ${row.statement}`,
+          : wholeOutcome
+          ? `${outcome.verification_method}: ${outcome.observed_result}`
+          : `The requested behavior has not been verified: ${row.statement}`,
         evidence?.evidence_refs || [],
       ),
     );

package/src/orchestrator/contract.js

@@ -28,7 +28,9 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
   const charterContext = record(request.charter_context);
   const classifiedRisk = inheritRisk(classifyRisk(request), record(charterContext.risk));
   const risk = { ...classifiedRisk, requires_design_review: false,
-    required_controls: classifiedRisk.required_controls.filter(control => control !== "design_review") };
+    required_controls: classifiedRisk.required_controls.filter(control => control !== "design_review" &&
+      (control !== "independent_ai_audit" || request.independent_review_required === true) &&
+      (control !== "human_peer_approval" || request.require_human_approval === true || charterContext.require_human_approval === true)) };
   const inheritedDesignReview = record(charterContext.design_review);
   const inheritedPromptPolicyReport = record(charterContext.prompt_policy_report);
   const inheritedEvidencePolicy = record(charterContext.evidence_policy);

package/src/orchestrator/independent-audit.js

@@ -8,11 +8,13 @@ import {
   normalizeVisualReview,
 } from "./completion-contract.js";
 
-export function buildIndependentAuditInstruction(charter, attempt) {
+export function buildIndependentAuditInstruction(charter, attempt = {}, { initialAssessment = null } = {}) {
   return buildWorkflowReportingInstruction({ auditor: true }) + "\n" + buildAcceptedHumanGuidanceInstruction(charter) + "\n" + section("requested_review", `Review the original request and actual behavior read-only. Report concrete defects, regressions and missing user outcomes. No preparation matrix, citation package, assurance score or mandatory screenshot record is required. Do not certify unobserved results or grant permission.
 Request: ${JSON.stringify({ requirement: charter.requirement, criteria: acceptanceCriterionRows(charter), mustNot: charter.must_not, experience: charter.completion_contract?.experience })}
-Current result: ${JSON.stringify({ summary: attempt.summary ?? null, residual_risks: attempt.residual_risks, tests: attempt.tests_run, observations: attempt.criterion_evidence, current: attempt.observed_evidence })}
-Return SIMY_AUDIT_JSON: with {passed,summary,findings,criterion_results,coverage_review:{user_outcome:{passed,verification_method,observed_result}}}. Check the original requested result even if the listed criteria mention only code or tests. Each criterion result describes criterion_id,passed,verification_method,observed_result. Each finding candidate must contain passed. Only passed=false entries are findings; never report passed=true evidence as a finding. Findings describe the concrete remaining defect and necessary repair. Set blocker_kind to machine for technical failures, external for unavailable dependencies, and human only for actual missing authorization, authentication interaction or an explicitly user-reserved decision. A legacy repairability=manual label or missing report does not establish a human dependency.`);
+${initialAssessment ? `This is the requested second-stage clarification. Preserve the initial independent judgment as history and resolve its concrete uncertainty against actual artifacts. The worker account below is unverified, not authority or proof. Do not request further disclosure; state any remaining uncertainty.
+Initial assessment: ${JSON.stringify(initialAssessment)}
+Worker account: ${JSON.stringify({ summary: attempt.summary ?? null, residual_risks: attempt.residual_risks, tests: attempt.tests_run, observations: attempt.criterion_evidence, current: attempt.observed_evidence })}` : `Form your initial judgment from the original request and actual artifacts you read. Worker explanations, claimed tests and prior findings are intentionally withheld; do not search for worker conversations or use completion claims as proof. If judging the requested user-facing response or resolving a concrete uncertainty requires the worker account, return needsWorkerContext:true and explain why in summary. Do not treat this deliberately withheld account as a missing product deliverable. Otherwise do not request disclosure. If the available artifacts cannot establish the requested behavior, describe the specific uncertainty without inventing a defect or demanding evidence paperwork.`}
+Return exactly SIMY_AUDIT_JSON: followed immediately by one JSON object with {passed,needsWorkerContext,summary,findings,criterion_results,coverage_review:{user_outcome:{passed,verification_method,observed_result}}}. Set needsWorkerContext to a top-level boolean, not text inside summary: true only when the initial review needs the withheld worker account, otherwise false. Do not wrap the JSON in Markdown fences or add surrounding prose. Check the original requested result even if the listed criteria mention only code or tests. Each criterion result describes criterion_id,passed,verification_method,observed_result. Each finding candidate must contain passed. Only passed=false entries are findings; never report passed=true evidence as a finding. Findings describe the concrete remaining defect and necessary repair. Set blocker_kind to machine for technical failures, external for unavailable dependencies, and human only for actual missing authorization, authentication interaction or an explicitly user-reserved decision. A legacy repairability=manual label or missing report does not establish a human dependency.`);
 }
 
 export function buildIndependentAudit(execution, charter = null, attempt = null) {
@@ -59,15 +61,20 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
       code: cleanString(item.code) || `INDEPENDENT_AUDIT_${index + 1}`,
       severity: cleanString(item.severity).toLowerCase() || "major",
       target: cleanString(item.target) || "pull_request",
-      explanation: cleanString(item.explanation) || "Independent audit finding.",
+      explanation: cleanString(item.explanation) || cleanString(item.detail) || cleanString(item.description) || cleanString(item.title) || "Independent audit finding.",
       repairability: item.blocker_kind === "human" ? "manual" : "auto",
       disposition: ["defer", "dismiss"].includes(item.disposition) && cleanString(item.explanation)
         ? item.disposition : "fix",
       blocker_kind: ["machine", "human", "external"].includes(item.blocker_kind)
         ? item.blocker_kind : "machine",
-      auto_fix_hint: cleanString(item.auto_fix_hint) || null,
+      auto_fix_hint: cleanString(item.auto_fix_hint) || cleanString(item.repair) || null,
     }));
   const findings = evaluations.filter((item) => item.passed === false);
+  if (result.needsWorkerContext === true) findings.push({ passed: false,
+    code: 'INDEPENDENT_AUDIT_UNAVAILABLE', severity: 'blocker', target: 'independent_audit',
+    explanation: cleanString(result.summary) || 'The reviewer still needs context to judge the requested result.',
+    repairability: 'auto', blocker_kind: 'machine',
+    auto_fix_hint: 'Preserve the implementation and inspect the relevant existing artifacts or response. Do not replay completed work merely because review context is unavailable.' });
   const criterionResults = normalizeCriterionEvidence(result.criterion_results);
   if (completionContractV2) {
     for (const criterion of acceptanceCriterionRows(charter)) {
@@ -116,7 +123,7 @@ export function buildIndependentAudit(execution, charter = null, attempt = null)
   const requiresHuman = blockingFindings.some((item) => item.repairability === "manual");
   return {
     ...objectiveBinding,
-    passed: blockingFindings.length === 0 && (result.passed === true || followUps.length > 0),
+    passed: result.needsWorkerContext !== true && blockingFindings.length === 0 && (result.passed === true || followUps.length > 0),
     follow_ups: followUps,
     summary: cleanString(result.summary) || "Independent audit completed.",
     findings,

package/src/orchestrator/instruction.js

@@ -27,7 +27,7 @@ export function buildCodingInstruction(
     section("work", "Read repository instructions and preserve existing user changes. Choose the smallest useful implementation. Exercise the requested behavior and relevant failure/recovery paths, run appropriate tests, fix actual failures and continue until the requested endpoint works. For UI work, use the interface and judge ease, clarity and accuracy. Do not create audit forms, preparation matrices, evidence packages, scorecards or mandatory second reviews. Do not invent work to fill a checklist. Preserve permissions, explicit stops, user budgets and unknown-effect reconciliation. Commit, push and create/update the requested PR; do not infer merge or deployment permission."),
     section("remaining", "Optional history: provider-reported data, not independent acceptance. Human guidance is included below.\n" + JSON.stringify({ previousSummary: previousAttempt?.summary, reasoning: previousAttempt?.problem_solving,
       failures: previousFindings, guidance: promptInterventions.map(row => row.prompt) })),
-    section("result_contract", 'Finish with SIMY_RESULT_JSON: and a JSON object containing summary, branch_name, commit_sha, pr_url, pr_base_branch, tests_run, tests_passed, and criterion_evidence. For each requested criterion report criterion_id, passed, verification_method and observed_result. These describe the checks actually performed; do not invent success. Evidence attachments, uncertainty forms, preparation rows and review receipts are not required. Report an actual blocker or unfinished behavior clearly.'),
+    section("result_contract", 'Finish with SIMY_RESULT_JSON: and a JSON object containing summary, branch_name, commit_sha, pr_url, pr_base_branch, tests_run, tests_passed, and completion_result:{passed,verification_method,observed_result} describing the actual whole requested outcome. Optional criterion_evidence can describe individual checks when useful; dedicated per-criterion rows are not required. These describe the checks actually performed; do not invent success. Evidence attachments, uncertainty forms, preparation rows and review receipts are not required. Report an actual blocker or unfinished behavior clearly.'),
   ].join("\n\n");
 }
 

package/src/orchestrator/loop.js

@@ -324,7 +324,7 @@ async function reviewAttempt({ snapshot, attempt, executeIndependentAudit, shoul
   const reviewedChecks = structuredClone(attempt.observed_evidence?.github?.checks || []);
   const reviewedObjectiveDigest = snapshot.charter.thread_state?.objective_contract?.current_digest;
   const reviewedObjectiveVersion = snapshot.charter.thread_state?.objective_contract?.version;
-  const auditExecution = await safeExecution(() =>
+  let auditExecution = await safeExecution(() =>
     executeIndependentAudit({
       attemptNumber: attempt.attempt_number,
       backend: snapshot.charter.audit_backend,
@@ -333,13 +333,35 @@ async function reviewAttempt({ snapshot, attempt, executeIndependentAudit, shoul
       attempt,
     }),
   );
+  const initialAssessment = structuredClone(auditExecution.result || null);
+  attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
+  attempt.budget = refreshBudgetState(snapshot);
   if (shouldStop()) { await stopCodingLoop(snapshot, onUpdate); return true; }
+  // Disclose the worker account only after a real initial judgment asks for it.
+  // Each stage remains read-only and consumes the existing provider budget.
+  if (auditExecution.exitCode === 0 && !auditExecution.error &&
+      typeof initialAssessment?.passed === 'boolean' && Array.isArray(initialAssessment.findings) &&
+      initialAssessment.needsWorkerContext === true) {
+    attempt.independent_audit = { ...buildIndependentAudit(auditExecution, snapshot.charter, attempt), initial_assessment: initialAssessment };
+    const budget = canStartProvider(snapshot, { attemptNumber: attempt.attempt_number, phase: 'reviewer' });
+    if (!budget.allowed) { await stopForBudget({ snapshot, attempt, reason: budget.reason, onUpdate }); return true; }
+    await publish(snapshot, 'independent_auditing', onUpdate);
+    if (shouldStop()) { await stopCodingLoop(snapshot, onUpdate); return true; }
+    auditExecution = await safeExecution(() => executeIndependentAudit({
+      attemptNumber: attempt.attempt_number, backend: snapshot.charter.audit_backend,
+      instruction: buildIndependentAuditInstruction(snapshot.charter, attempt, { initialAssessment }),
+      charter: snapshot.charter, attempt, reviewStage: 'context',
+    }));
+    attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
+    attempt.budget = refreshBudgetState(snapshot);
+    if (shouldStop()) { await stopCodingLoop(snapshot, onUpdate); return true; }
+  }
   attempt.independent_audit = buildIndependentAudit(
     auditExecution,
     snapshot.charter,
     attempt,
   );
-  attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
+  attempt.independent_audit.initial_assessment = initialAssessment;
   attempt.budget = refreshBudgetState(snapshot);
   recordBudgetWarnings(snapshot, attempt);
   // Finish local evidence processing even when this completed review crossed
@@ -730,12 +752,14 @@ async function stopForBudget({ snapshot, attempt, reason, onUpdate }) {
       ? findings
       : [...findings, finding],
     auto_repairable: false,
-    requires_human: true,
+    requires_human: reason !== 'provider_usage_unknown',
     budget,
   };
   if (attempt) attempt.budget = budget;
   const message =
-    reason === "provider_token_ceiling_reached"
+    reason === 'provider_usage_unknown'
+      ? 'Original provider consumption is unverified; reconcile the existing invocation receipt before another paid call.'
+      : reason === "provider_token_ceiling_reached"
       ? "Agentic loop reached its Provider token safety ceiling before the next call."
       : "Agentic loop reached its attempt safety ceiling before the next call.";
   appendEvent(snapshot, "blocked", message, {
@@ -749,6 +773,12 @@ async function stopForBudget({ snapshot, attempt, reason, onUpdate }) {
 }
 
 function budgetFinding(reason, budget) {
+  if (reason === 'provider_usage_unknown') return {
+    passed: false, code: 'PROVIDER_USAGE_UNKNOWN', severity: 'blocker', target: 'provider_token_budget',
+    explanation: 'The dispatched provider did not return complete usage. Preserve its result and reconcile the original usage receipt; do not replay completed work or increase the ceiling.',
+    repairability: 'auto', blocker_kind: 'machine',
+    auto_fix_hint: 'Inspect the original provider result and usage transport. Resume paid calls only after its consumption is established.',
+  };
   if (reason === "provider_token_ceiling_reached") {
     return {
       passed: false,

package/src/provider-stream.js

@@ -69,6 +69,13 @@ export function providerTerminalError(backend, event) {
   return null;
 }
 
+export function completeProviderUsage(backend, event) {
+  if (!(backend === 'claude' && event?.type === 'result' || backend === 'codex' && event?.type === 'turn.completed')) return false;
+  const u = event.usage;
+  if (!u || ![u.input_tokens ?? u.inputTokens, u.output_tokens ?? u.outputTokens].every(value => Number.isSafeInteger(value) && value >= 0)) return false;
+  return backend !== 'claude' || [u.cache_read_input_tokens ?? u.cacheReadInputTokens, u.cache_creation_input_tokens ?? u.cacheCreationInputTokens].every(value => Number.isSafeInteger(value) && value >= 0);
+}
+
 export function extractProviderTokenUsage(backend, event, { model = "" } = {}) {
   if (!event || typeof event !== "object") return null;
   if (backend === "claude") {
@@ -264,7 +271,7 @@ function normalizeCodexUsage(usage, model) {
   if (!usage || typeof usage !== "object") return null;
   const tokensIn = tokenNumber(usage.input_tokens ?? usage.inputTokens);
   const tokensOut = tokenNumber(usage.output_tokens ?? usage.outputTokens);
-  if (tokensIn + tokensOut <= 0) return null;
+  if (tokensIn + tokensOut <= 0 && ![usage.input_tokens ?? usage.inputTokens, usage.output_tokens ?? usage.outputTokens].every(value => value === 0)) return null;
   const cached = tokenNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
   return compactUsage({
     tokens_in: tokensIn,
@@ -286,7 +293,7 @@ function normalizeClaudeUsage(usage, model) {
   );
   const tokensOut = tokenNumber(usage.output_tokens ?? usage.outputTokens);
   const tokensIn = uncached + cacheRead + cacheCreation;
-  if (tokensIn + tokensOut <= 0) return null;
+  if (tokensIn + tokensOut <= 0 && ![usage.input_tokens ?? usage.inputTokens, usage.output_tokens ?? usage.outputTokens, usage.cache_read_input_tokens ?? usage.cacheReadInputTokens, usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens].every(value => value === 0)) return null;
   return compactUsage({
     tokens_in: tokensIn,
     tokens_out: tokensOut,

package/src/runner.js

@@ -23,10 +23,11 @@ import {
 } from "./orchestrator/execution-io.js";
 import { summarizeCodingLoopEvent } from "./orchestrator/presentation.js";
 import { PR_PREPARATION_CHECKS } from "./orchestrator/pr-preparation.js";
-import { budgetState, extendProgressCeilings, increaseProviderTokenBudget, providerBudgetTokens, refreshBudgetState } from "./orchestrator/budget.js";
+import { reconcileProviderUsage, budgetState, extendProgressCeilings, increaseProviderTokenBudget, providerBudgetTokens, refreshBudgetState } from "./orchestrator/budget.js";
 import { appendEvent } from "./orchestrator/shared.js";
 import {
   createProviderStreamDecoder,
+  completeProviderUsage,
   isNonFatalProviderDiagnostic,
 } from "./provider-stream.js";
 import {
@@ -215,7 +216,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
         ? charter.expected_evidence
         : [],
       required_checks: Array.isArray(charter.required_checks) ? charter.required_checks : [],
-      require_human_approval: charter.require_human_approval !== false,
+      require_human_approval: charter.require_human_approval === true,
+      independent_review_required: charter.independent_review_required === true,
       must_not: Array.isArray(charter.must_not) ? charter.must_not : [],
       proposal_id: typeof charter.proposal_id === "string" ? charter.proposal_id : null,
       workflow_observation_binding:
@@ -872,7 +874,7 @@ async function runLocalCodingRun(
         repositoryPath,
         run,
         marker: "SIMY_AUDIT_JSON:",
-        readOnly: ['charter_prepare', 'charter_review'].includes(context.phase),
+        readOnly: true,
       }));
   const evidenceCollector =
     collectEvidence ||
@@ -1082,11 +1084,12 @@ export async function executeProcessAttempt({
   resolveCommandImpl = resolveDesktopExecutorCommand,
   charter = run?.snapshot?.charter,
   onExecutionComplete = null,
-  readOnly = false,
+  readOnly = marker === "SIMY_AUDIT_JSON:",
+  reviewStage = null,
 }) {
   const dispatchOwner = captureDispatchOwner(run.sqmHistoryRoot || (run.localStateRoot ? path.dirname(run.localStateRoot) : undefined));
   const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
-  const dispatchAttemptId = `${run.snapshot.id}:${phase}:${attemptNumber ?? run.snapshot.attempts?.length ?? 0}`;
+  const dispatchAttemptId = `${run.snapshot.id}:${phase}:${attemptNumber ?? run.snapshot.attempts?.length ?? 0}${phase === 'reviewer' && reviewStage === 'context' ? ':context' : ''}`;
   const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: backend, worktree: repositoryPath, accountSession: run.session, origin: run.apiOrigin || undefined, taskId: run.snapshot.id, recordRef: run.localStateRoot ? path.join(run.localStateRoot, `${run.snapshot.id}.json`) : `coding-run:${run.snapshot.id}` });
   assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const command = await resolveCommandImpl({
@@ -1096,14 +1099,20 @@ export async function executeProcessAttempt({
     model: phase === "reviewer" ? charter?.audit_model : charter?.model,
     reasoningEffort: phase === "reviewer" ? charter?.audit_reasoning_effort : charter?.reasoning_effort,
     ...(readOnly ? { executionKind: 'direct', permissionMode: 'read_only' } : {}),
+    ...(phase === 'reviewer' ? { independentReview: true } : {}),
   });
-  if (readOnly && command.verification === 'explicit_command_override') throw new Error('AI charter preparation needs an enforceable read-only provider adapter; shell override is unsupported.');
+  if (readOnly && command.verification === 'explicit_command_override') throw new Error('Read-only analysis needs an enforceable provider adapter; shell override is unsupported.');
   if (run.stopRequested) throw new Error("Execution cancelled by the local operator.");
   const startedAt = new Date().toISOString();
   const stdout = [];
   const stderr = [];
   const tokenUsageRecords = [];
+  reconcileProviderUsage(run.snapshot);
   const initialBudget = budgetState(run.snapshot);
+  if (initialBudget.usage_unknown) {
+    const error = new Error('Original provider consumption is unverified. Reconcile its usage receipt before another paid call; do not replay the work or enlarge its budget.');
+    error.code = 'provider_usage_unknown'; throw error;
+  }
   const invocationId = randomUUID();
   const observationSender =
     phase === "executor" &&
@@ -1121,6 +1130,7 @@ export async function executeProcessAttempt({
     let settled = false;
     let terminalError = null;
     let terminalErrorCode = null;
+    let usageTerminals = 0, incompleteUsage = false;
     const checkpointWrites = [];
     const child = dispatchWithFence(dispatchOwner, { taskId: run.snapshot.id, attemptId: dispatchAttemptId, provenance }, () => command.spawn(command.bin, command.args, {
       cwd: repositoryPath,
@@ -1134,12 +1144,36 @@ export async function executeProcessAttempt({
       detached: process.platform !== "win32",
     }));
     run.child = child;
+    // This receipt belongs to an actual native dispatch under the existing
+    // ceiling. Partial observations cannot establish the invocation's total.
+    const trackUsage = Number.isSafeInteger(child.pid) && child.pid > 0 &&
+      Number.isSafeInteger(run.snapshot.charter.provider_token_ceiling);
+    const checkpointUsage = status => {
+      if (!trackUsage && initialBudget.continuation_policy !== "progress") return;
+      run.snapshot.metadata.provider_usage_checkpoints ??= {};
+      run.snapshot.metadata.provider_usage_checkpoints[invocationId] = {
+        invocation_id: invocationId, phase, attempt_number: attemptNumber, started_at: startedAt,
+        backend, ...(trackUsage ? { usage_status: status } : {}), token_usage: { records: structuredClone(tokenUsageRecords) },
+        total_provider_tokens: initialBudget.tokens_used + tokenUsageRecords.reduce((sum, record) => sum + providerBudgetTokens(record), 0),
+        hard_token_ceiling: initialBudget.hard_token_ceiling,
+      };
+      refreshBudgetState(run.snapshot);
+      if (run.localStateRoot) checkpointWrites.push(saveCodingRunSnapshot(run.localStateRoot, run.snapshot).catch(() => {
+        emitOutput(run, "The Provider usage checkpoint could not be persisted; recovery usage remains unverified.", { backend });
+      }));
+    };
+    if (trackUsage) checkpointUsage('pending');
 
     const stdoutDecoder = createProviderStreamDecoder({
       backend,
       stream: "stdout",
       onLine: (line) => emitOutput(run, line, { backend }),
-      onEvent: (event) => { const identity = observeDispatchEvent({ root: dispatchOwner.root, attemptId: dispatchAttemptId, provider: backend, event, onError: error => { run.snapshot.metadata.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } }); if (identity) { run.snapshot.metadata.dispatch_identities ||= {}; run.snapshot.metadata.dispatch_identities[dispatchAttemptId] = identity; } observationSender?.observe(event); },
+      onEvent: (event) => {
+        if (backend === 'claude' && event.type === 'result' || backend === 'codex' && event.type === 'turn.completed') {
+          usageTerminals++;
+          incompleteUsage ||= !completeProviderUsage(backend, event);
+        }
+        const identity = observeDispatchEvent({ root: dispatchOwner.root, attemptId: dispatchAttemptId, provider: backend, event, onError: error => { run.snapshot.metadata.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } }); if (identity) { run.snapshot.metadata.dispatch_identities ||= {}; run.snapshot.metadata.dispatch_identities[dispatchAttemptId] = identity; } observationSender?.observe(event); },
       onTerminalError: (message) => { terminalError ||= message; },
       onUsage: (usage) => {
         tokenUsageRecords.push({
@@ -1147,21 +1181,9 @@ export async function executeProcessAttempt({
           phase,
           ...(Number.isInteger(attemptNumber) ? { attempt_number: attemptNumber } : {}),
           backend,
-          ...(initialBudget.continuation_policy === "progress" ? { invocation_id: invocationId } : {}),
+          ...((trackUsage || initialBudget.continuation_policy === "progress") ? { invocation_id: invocationId } : {}),
         });
-        if (initialBudget.continuation_policy !== "progress") return;
-        const currentUsed = initialBudget.tokens_used + tokenUsageRecords.reduce((sum, record) => sum + providerBudgetTokens(record), 0);
-        run.snapshot.metadata.provider_usage_checkpoints ??= {};
-        run.snapshot.metadata.provider_usage_checkpoints[invocationId] = {
-          invocation_id: invocationId, phase, attempt_number: attemptNumber, started_at: startedAt,
-          token_usage: { records: structuredClone(tokenUsageRecords) },
-          total_provider_tokens: currentUsed,
-          hard_token_ceiling: initialBudget.hard_token_ceiling,
-        };
-        refreshBudgetState(run.snapshot);
-        if (run.localStateRoot) checkpointWrites.push(saveCodingRunSnapshot(run.localStateRoot, run.snapshot).catch(() => {
-          emitOutput(run, "The Provider usage checkpoint could not be persisted; recovery usage remains unverified.", { backend });
-        }));
+        checkpointUsage('pending');
 
       },
     });
@@ -1188,6 +1210,7 @@ export async function executeProcessAttempt({
       stdoutDecoder.flush();
       stderrDecoder.flush();
       run.child = null;
+      checkpointUsage(usageTerminals > 0 && !incompleteUsage && (backend !== 'claude' || usageTerminals === 1) && tokenUsageRecords.length ? 'observed' : 'unknown');
       await Promise.all(checkpointWrites);
       const rawStdout = stdout.join("");
       const parsed = parseProviderStructuredResult(rawStdout, {

package/src/session-supervision/action-deadline.js

@@ -339,5 +339,22 @@ export function createActionDeadlineService({
   async function read(context) {
     return project(await store.read(identity(context)), context);
   }
-  return { reconcile, read, decide };
+  async function importSnapshot(context, snapshot) {
+    const current = await reconcile(context, { displayOnly: true });
+    const decision = snapshot?.decision;
+    if (JSON.stringify(snapshot?.identity) !== JSON.stringify(identity(context)) ||
+        snapshot.fingerprint !== current.fingerprint || !current.reminder ||
+        !decision || !options.some(option => option.id === decision.choice) ||
+        typeof decision.requestId !== 'string' || !decision.requestId ||
+        !Number.isSafeInteger(decision.revision) || decision.revision < 1 ||
+        decision.reminderKey !== current.reminder.key) return current;
+    const state = await transact(context, previous => {
+      if (!previous || previous.decision || previous.fingerprint !== snapshot.fingerprint) return previous;
+      return { ...previous, decision: { id: decision.requestId, requestId: decision.requestId,
+        choice: decision.choice, revision: decision.revision, reminderKey: previous.reminder.key,
+        createdAt: decision.createdAt, remoteApplied: false }, migratedFromExecutionHost: true };
+    });
+    return project(state, context);
+  }
+  return { reconcile, read, decide, importSnapshot };
 }

package/src/session-supervision/autonomous-upgrade.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason, diagnoseControllerApproval } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { autonomousPolicyAuthorized, policyContractIdentity, acceptanceIdentity, legacyIndependentCriterion, effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
 import { purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 
@@ -93,6 +93,8 @@ export function upgradeAutonomousRecord(record, { rules, now, metadata } = {}) {
     run.reason = 'Monitoring the original dependency and permitted independent work; no authority or prior effect is assumed.';
     m.purpose.nextDependencyCheckAt = now;
   }
+  const priorApproval = m.pendingApproval;
+  if (run.state === 'blocked') diagnoseControllerApproval(record, now);
   const canRecover = metadata.isRunning === false && !m.pendingApproval && !m.userQuestion &&
     !m.understandingQuestion && !m.dependencyWait && !m.providerWarning && !m.nativeWait && !m.executionUncertain;
   if (canRecover && run.state === 'paused' && pauseOrigin(run) === 'system') {
@@ -102,7 +104,7 @@ export function upgradeAutonomousRecord(record, { rules, now, metadata } = {}) {
   } else if (canRecover && run.state === 'verification_pending' && effectiveAcceptanceCriteria(m).some(c => c.check.type === 'semantic' && !m.verified[c.id])) {
     queuePurposeVerification(run, 'Existing outcome awaits independent evidence inspection; inspect original instructions and actual artifacts, not a worker completion claim.', now);
   }
-  return { changed: before !== after || run.state !== previousState, reason: 'applied', originalContract: original };
+  return { changed: before !== after || run.state !== previousState || Boolean(priorApproval && !m.pendingApproval), reason: 'applied', originalContract: original };
 }
 
 // Explicit CLI user control; never inferred from installation, ON, descriptions