@awak-app/simy-cli 0.5.71 → 0.5.73

package/src/device-signing-identity.js

@@ -0,0 +1,65 @@
+import { constants } from "node:fs";
+import { mkdir, open, lstat } from "node:fs/promises";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync } from "node:crypto";
+import path from "node:path";
+
+// Shared SQM/Purpose identity. Inspection never creates or repairs a key.
+export async function loadDeviceSigningIdentity(location, { create = false } = {}) {
+  const parent = path.dirname(location);
+  if (create) await mkdir(parent, { recursive: true, mode: 0o700 });
+  try {
+    const directory = await lstat(parent);
+    if (!directory.isDirectory() || directory.isSymbolicLink() || (process.platform !== "win32" && (directory.mode & 0o022) !== 0)) throw new Error("Unsafe signing key directory.");
+    const details = await lstat(location);
+    assertPrivateFile(details);
+    const handle = await open(location, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    try {
+      const opened = await handle.stat();
+      assertPrivateFile(opened);
+      if (opened.ino !== details.ino || opened.dev !== details.dev || opened.size > 4096) throw new Error("Signing key changed while opening.");
+      const raw = await handle.readFile("utf8");
+      const after = await handle.stat();
+      if (after.size !== opened.size || after.mtimeMs !== opened.mtimeMs) throw new Error("Signing key changed while reading.");
+      const parsed = JSON.parse(raw);
+      const privateKey = createPrivateKey({ key: decode(parsed.private_key), format: "der", type: "pkcs8" });
+      const publicKeyDer = createPublicKey(privateKey).export({ format: "der", type: "spki" });
+      const keyId = `sha256:${createHash("sha256").update(publicKeyDer).digest("hex")}`;
+      if (privateKey.asymmetricKeyType !== "ed25519" || parsed.algorithm !== "ed25519" ||
+          parsed.key_id !== keyId || !decode(parsed.public_key).equals(publicKeyDer)) throw new Error("Signing key pair does not match.");
+      return { privateKey, publicKeyDer, keyId };
+    } finally { await handle.close(); }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    if (!create) return null;
+  }
+  const pair = generateKeyPairSync("ed25519");
+  const publicKeyDer = pair.publicKey.export({ format: "der", type: "spki" });
+  const keyId = `sha256:${createHash("sha256").update(publicKeyDer).digest("hex")}`;
+  let handle;
+  try {
+    handle = await open(location, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0), 0o600);
+  } catch (error) {
+    if (error.code === "EEXIST") return loadDeviceSigningIdentity(location);
+    throw error;
+  }
+  try {
+    await handle.writeFile(`${JSON.stringify({ algorithm: "ed25519", key_id: keyId,
+      private_key: pair.privateKey.export({ format: "der", type: "pkcs8" }).toString("base64"),
+      public_key: publicKeyDer.toString("base64"), created_at: new Date().toISOString() })}\n`);
+    await handle.sync();
+  } finally { await handle.close(); }
+  return { privateKey: pair.privateKey, publicKeyDer, keyId };
+}
+
+function assertPrivateFile(details) {
+  if (!details.isFile() || details.isSymbolicLink() || details.nlink !== 1 ||
+      (process.platform !== "win32" && ((details.mode & 0o077) !== 0 ||
+        (typeof process.getuid === "function" && details.uid !== process.getuid())))) throw new Error("Signing key must be a private regular file.");
+}
+
+function decode(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(value)) throw new Error("Invalid signing key encoding.");
+  const bytes = Buffer.from(value, "base64");
+  if (bytes.toString("base64") !== value) throw new Error("Invalid signing key encoding.");
+  return bytes;
+}

package/src/diagnostic-log.js

@@ -0,0 +1,68 @@
+import { randomUUID, createHash } from "node:crypto";
+import { mkdir, appendFile, rename, writeFile, readdir, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { defaultSessionRoot } from "./session-store.js";
+
+const writers = new Map();
+const scopeDir = (root, scope) => join(root, "diagnostics", createHash("sha256").update(JSON.stringify([
+  scope?.webOrigin, scope?.accountId, scope?.organizationId,
+])).digest("hex"));
+const safeIdentifier = value => typeof value === "string" && /^[a-z][a-z0-9_.-]{0,79}$/i.test(value) ? value : null;
+
+// Only structured diagnostics are durable. Never retain prompts, arbitrary error
+// messages, tokens, source paths, or provider stdout/stderr.
+export function safeDiagnosticEvent(value, now = () => Date.now()) {
+  return { at: Number.isFinite(Date.parse(value?.at)) ? value.at : new Date(now()).toISOString(),
+    kind: ["analysis", "check", "preflight"].includes(value?.kind) ? value.kind : "check",
+    stage: safeIdentifier(value?.stage) || "unknown",
+    code: safeIdentifier(value?.code) || "failure_unclassified",
+    provider: ["codex", "claude"].includes(value?.provider) ? value.provider : null,
+    http_status: Number.isInteger(value?.http_status) && value.http_status >= 400 && value.http_status <= 599 ? value.http_status : null };
+}
+
+export function diagnosticLogger({ root = defaultSessionRoot(), scope, maxBytes = 64 * 1024, segments = 4, now } = {}) {
+  if (!scope?.webOrigin || !scope?.accountId || !scope?.organizationId) return { record: async () => false };
+  const dir = scopeDir(root, scope), cacheKey = `${dir}:${maxBytes}:${segments}`;
+  if (writers.has(cacheKey)) return writers.get(cacheKey);
+  const id = randomUUID();
+  let queue = Promise.resolve(), total = 0, bytes = 0, segment = 0, firstAt = null;
+  const writer = { record(value) {
+    const task = queue.catch(() => {}).then(async () => {
+      const event = safeDiagnosticEvent(value, now), line = `${JSON.stringify(event)}\n`;
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      if (bytes + Buffer.byteLength(line) > maxBytes && bytes > 0) {
+        segment += 1; bytes = 0;
+        if (segment >= segments) await rm(join(dir, `${id}.${segment - segments}.jsonl`), { force: true });
+      }
+      await appendFile(join(dir, `${id}.${segment}.jsonl`), line, { mode: 0o600 });
+      bytes += Buffer.byteLength(line); total += 1; firstAt ||= event.at;
+      const meta = join(dir, `${id}.json`), temp = `${meta}.tmp`;
+      await writeFile(temp, JSON.stringify({ schema_version: 1, total_failures: total, first_failure_at: firstAt, last_failure_at: event.at }), { mode: 0o600 });
+      await rename(temp, meta);
+      return true;
+    });
+    queue = task; return task;
+  } };
+  writers.set(cacheKey, writer); return writer;
+}
+
+export async function readDiagnosticLog({ root = defaultSessionRoot(), scope, limit = 20 } = {}) {
+  if (!scope?.webOrigin || !scope?.accountId || !scope?.organizationId) return { total_failures: 0, first_failure_at: null, recent: [] };
+  const dir = scopeDir(root, scope);
+  let names;
+  try { names = await readdir(dir); } catch (error) { if (error.code === "ENOENT") return { total_failures: 0, first_failure_at: null, recent: [] }; throw error; }
+  let total = 0, first = null; const events = [];
+  for (const name of names.filter(name => /^[a-f0-9-]{36}(?:\.\d+\.jsonl|\.json)$/.test(name))) {
+    const content = await readFile(join(dir, name), "utf8").catch(() => "");
+    if (name.endsWith(".json")) {
+      try { const meta = JSON.parse(content); if (Number.isSafeInteger(meta.total_failures) && meta.total_failures >= 0) total += meta.total_failures;
+        if (Number.isFinite(Date.parse(meta.first_failure_at)) && (!first || meta.first_failure_at < first)) first = meta.first_failure_at; } catch {}
+    } else {
+      for (const line of content.slice(0, 128 * 1024).split("\n")) {
+        try { const event = JSON.parse(line); if (Number.isFinite(Date.parse(event.at))) events.push(safeDiagnosticEvent(event)); } catch {}
+      }
+    }
+  }
+  return { total_failures: total, first_failure_at: first,
+    recent: events.sort((a, b) => b.at.localeCompare(a.at)).slice(0, Math.max(0, Math.min(100, limit))) };
+}

package/src/doctor.js

@@ -0,0 +1,55 @@
+import { purposeSigningKeyPath, purposeVerificationCapability } from "./purpose-local-proof.js";
+import { readFile } from "node:fs/promises";
+import { connectionDiscoveryPath } from "./connection-discovery.js";
+import { readSession, isSessionValid, defaultSessionRoot } from "./session-store.js";
+import { inspectProviderStatus } from "./desktop-status.js";
+import { readDiagnosticLog } from "./diagnostic-log.js";
+
+export async function collectDiagnostics({ webOrigin, cliVersion, root = defaultSessionRoot(),
+  readSessionImpl = readSession, inspectProvider = inspectProviderStatus, fetchImpl = fetch,
+  readFileImpl = readFile, alive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } }, now = Date.now() } = {}) {
+  const session = await readSessionImpl(webOrigin, root).catch(() => null);
+  const valid = isSessionValid(session, now, webOrigin);
+  let daemon = { state: "not_found", cli_version: null, version_matches: null };
+  try {
+    const record = JSON.parse(await readFileImpl(connectionDiscoveryPath(webOrigin, root), "utf8"));
+    if (record.web_origin !== webOrigin || !Number.isInteger(record.port) || record.port < 1 || record.port > 65535 ||
+      !Number.isInteger(record.pid) || record.pid <= 0) throw new Error("Invalid discovery");
+    if (!alive(record.pid)) daemon.state = "stale_record";
+    else {
+      const response = await fetchImpl(`http://127.0.0.1:${record.port}/v1/health`, {
+        headers: { Origin: webOrigin }, signal: AbortSignal.timeout(1500), redirect: "error" });
+      const health = response.ok ? await response.json() : null;
+      if (health?.web_origin !== webOrigin || health?.ok !== true) throw new Error("Unverified daemon");
+      const version = typeof health.cli_version === "string" && /^\d+\.\d+\.\d+$/.test(health.cli_version) ? health.cli_version : null;
+      daemon = { state: "reachable", cli_version: version, version_matches: version ? version === cliVersion : null,
+        background: health.daemon === true };
+    }
+  } catch (error) { if (error.code !== "ENOENT") daemon.state = "unverified"; }
+  const providers = Object.fromEntries(await Promise.all(["codex", "claude"].map(async provider => {
+    const result = await inspectProvider(provider).catch(() => ({ state: "unknown" }));
+    return [provider, { state: ["ready", "signed_out", "missing", "outdated", "unknown"].includes(result?.state) ? result.state : "unknown",
+      version: typeof result?.version === "string" && /^\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?$/i.test(result.version) ? result.version : null,
+      model_access: "unknown" }];
+  })));
+  const scope = session?.account_id && session?.organization_id ? { webOrigin, accountId: session.account_id, organizationId: session.organization_id } : null;
+  const failures = await readDiagnosticLog({ root, scope }).catch(() => ({ status: "unavailable", recent: [] }));
+  return { schema_version: 1, cli_version: cliVersion, web_origin: webOrigin, daemon,
+    session: { state: valid ? "signed_in" : session ? "expired" : "signed_out",
+      expires_at: Number.isFinite(Date.parse(session?.expires_at)) ? session.expires_at : null },
+    providers, failures,
+    purpose_verification: await purposeVerificationCapability(purposeSigningKeyPath(root)).then(value => ({ state: value ? "available" : "not_initialized", key_id: value?.key_id || null, execution: "explicit_frozen_recipes_only" })).catch(() => ({ state: "unavailable", key_id: null, execution: "explicit_frozen_recipes_only" })),
+    actions: [
+      ...(!valid ? [{ id: "reconnect_cli", command: "simy" }] : []),
+      ...(["stale_record", "not_found", "unverified"].includes(daemon.state) ? [{ id: "inspect_daemon", command: "simy doctor" }] : []),
+      ...(daemon.version_matches === false ? [{ id: "update_when_idle", command: "simy update --check" }] : []),
+      ...Object.entries(providers).filter(([, provider]) => provider.state === "signed_out")
+        .map(([provider]) => ({ id: `login_${provider}`, command: provider === "codex" ? "codex login" : "claude auth login" })),
+    ] };
+}
+
+export async function runDoctor(options) {
+  const diagnostics = await collectDiagnostics(options);
+  console.log(JSON.stringify(diagnostics, null, 2));
+  return 0;
+}

package/src/index.js

@@ -7,6 +7,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { startAgent } from "./agent.js";
+import { createRuntimeDiagnostics, captureRuntimeOutput } from "./runtime-diagnostics.js";
 import {
   autoUpdateHelpText,
   createCliAutoUpdater,
@@ -34,8 +35,16 @@ const entryPath = fileURLToPath(import.meta.url);
 const packageInfo = await readCliPackageInfo();
 const updatesDisabled = args.has("--no-auto-update") || process.env.SIMY_AUTO_UPDATE === "0";
 let configuredWebOrigin;
+const versionOnly = dispatchArgv.length === 1 && ["--version", "-v"].includes(dispatchArgv[0]);
+if (versionOnly) {
+  console.log(packageInfo.version);
+} else if (process.env.SIMY_DAEMON_CHILD === "1" && (args.has("--daemon") || args.has("--deamon"))) {
+  const diagnostics = createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"));
+  captureRuntimeOutput(diagnostics);
+  diagnostics.write(`daemon starting version=${packageInfo.version} pid=${process.pid}`);
+}
 try {
-  configuredWebOrigin = resolveWebOrigin(readOption(argv, "--host"));
+  if (!versionOnly) configuredWebOrigin = resolveWebOrigin(readOption(argv, "--host"));
 } catch (error) {
   console.error(error instanceof Error ? error.message : String(error));
   process.exitCode = 2;
@@ -43,6 +52,11 @@ try {
 
 if (!configuredWebOrigin) {
   // Invalid host input is reported above before update discovery or startup.
+} else if (args.has("--version") || args.has("-v")) {
+  console.log(packageInfo.version);
+} else if (dispatchArgv[0] === "doctor") {
+  const { runDoctor } = await import("./doctor.js");
+  process.exitCode = await runDoctor({ webOrigin: configuredWebOrigin, cliVersion: packageInfo.version });
 } else if (dispatchArgv[0] === "update") {
   const checkOnly = args.has("--check");
   const result = await runCliUpdateGate({
@@ -111,6 +125,8 @@ async function runCommand(installMode) {
   if (args.has("--help") || args.has("-h")) {
     console.log(`Usage:
   simy            Start the local SIMY agent
+  simy --version  Print the installed version without starting or updating
+  simy doctor     Read-only version, connection, provider and failure diagnostics
   simy --daemon   Start it in the background
   simy --no-tui   Start the foreground HTTP agent without the interactive console
   simy sqm min-check  Run the fast deterministic SQM diff preflight
@@ -121,6 +137,7 @@ async function runCommand(installMode) {
   simy update         ${installMode === "macos_installer" ? "Show Apple Silicon update status and installer action" : "Install an eligible stable CLI update"}
 
 Options:
+  --version, -v       Print the installed CLI version and exit
   --daemon, --deamon  Run detached in the background
   --no-tui            Disable the interactive Agentic Loop console
   --no-open           Do not open the browser when authorization is required

package/src/local-task.js

@@ -1,3 +1,4 @@
+import { normalizePurposeVerification } from "./purpose-local-proof.js";
 import { buildWorkflowReportingInstruction } from "./workflow-reporting.js";
 import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
@@ -20,6 +21,7 @@ import { promisify } from "node:util";
 
 import { resolveDesktopExecutorCommand } from "./desktop-executor.js";
 import { providerBudgetTokens } from "./orchestrator/budget.js";
+import { continuationMode } from "./continuation-policy.js";
 import {
   buildLocalTaskArtifactRefs,
   MAX_LOCAL_TASK_ARTIFACT_REFS,
@@ -257,15 +259,21 @@ export function createLocalTask({
   expectedOutputs = [],
   scenarioPack = null,
   providerTokenBudget = DEFAULT_LOCAL_TASK_TOKEN_BUDGET,
+  continuationPolicy = "bounded",
+  providerTokenCeiling = MAX_LOCAL_TASK_TOKEN_BUDGET,
   timeoutMs = DEFAULT_LOCAL_TASK_TIMEOUT_MS,
   idempotencyKeyHash = null,
   requestFingerprint = null,
   workflowObservationBinding = null,
   workflowStartIntent = null,
+  purposeVerification = null,
 }) {
   validateTaskId(id);
   const now = new Date().toISOString();
   const tokenBudget = normalizeTokenBudget(providerTokenBudget);
+  const policy = continuationMode(continuationPolicy);
+  const tokenCeiling = normalizeTokenBudget(providerTokenCeiling);
+  if (policy === "progress" && tokenCeiling < tokenBudget) throw new Error("The hard Provider token ceiling cannot be below the notification threshold.");
   const normalizedTimeout = normalizeTimeoutMs(timeoutMs);
   const normalizedScenarioPack = normalizeLocalTaskScenarioPack(scenarioPack);
   const scenarioExpectedOutputs =
@@ -284,6 +292,7 @@ export function createLocalTask({
   return {
     id,
     kind: "local_task",
+    ...(purposeVerification ? { purpose_verification: normalizePurposeVerification(purposeVerification) } : {}),
     idempotency_key_hash: idempotencyKeyHash,
     request_fingerprint: requestFingerprint,
     status: "queued",
@@ -316,6 +325,8 @@ export function createLocalTask({
     error: null,
     reason_code: null,
     provider_token_budget: tokenBudget,
+    continuation_policy: policy,
+    provider_token_ceiling: policy === "progress" ? tokenCeiling : tokenBudget,
     provider_tokens_used: 0,
     token_usage: { records: [] },
     ...(normalizedWorkflowObservationBinding
@@ -368,11 +379,14 @@ export function createLocalTaskRequestFingerprint({
   repository,
   expectedOutputs,
   providerTokenBudget,
+  continuationPolicy = "bounded",
+  providerTokenCeiling = MAX_LOCAL_TASK_TOKEN_BUDGET,
   timeoutMs,
   attachmentManifest,
   scenarioPack,
   workflowObservationBinding = null,
   workflowStartIntent = null,
+  purposeVerification = null,
 }) {
   const normalizedModel = normalizeLocalTaskModel(model);
   const manifest = Array.isArray(attachmentManifest)
@@ -398,6 +412,7 @@ export function createLocalTaskRequestFingerprint({
   }
   const payload = {
     instruction: String(instruction || "").trim(),
+    ...(purposeVerification ? { purpose_verification: normalizePurposeVerification(purposeVerification) } : {}),
     backend: String(backend || ""),
     ...(normalizedModel ? { model: normalizedModel } : {}),
     operation: String(operation || ""),
@@ -406,6 +421,10 @@ export function createLocalTaskRequestFingerprint({
     repository: String(repository || "").trim() || null,
     expected_outputs: normalizeExpectedOutputs(expectedOutputs),
     provider_token_budget: normalizeTokenBudget(providerTokenBudget),
+    ...(continuationMode(continuationPolicy) === "progress" ? {
+      continuation_policy: "progress",
+      provider_token_ceiling: normalizeTokenBudget(providerTokenCeiling),
+    } : {}),
     timeout_ms: normalizeTimeoutMs(timeoutMs),
     attachment_manifest: manifest,
     scenario_pack: normalizeLocalTaskScenarioPack(scenarioPack),
@@ -426,6 +445,7 @@ export async function startLocalTask(
     environment = process.env,
     persist = persistLocalTask,
     beforeProviderInvocation = null,
+    beforeSpawn = null,
     session = null,
     apiOrigin = null,
     observationFetch = globalThis.fetch,
@@ -509,6 +529,7 @@ export async function startLocalTask(
   // synchronous spawn boundary so a stopped task can never start Provider work.
   if (task.stop_requested || task.status !== "running") return task;
 
+
   const observationSender = createWorkflowObservationSender({
     binding: task.workflow_observation_binding,
     startIntent: task.workflow_start_intent,
@@ -523,6 +544,27 @@ export async function startLocalTask(
     path.join(runtimeTempBase, `simy-local-task-${task.id}-`),
   );
   allowCodexRuntimeTemp(command, runtimeTempRoot);
+  // Temp preparation is asynchronous too: the final authority check belongs
+  // after it, immediately adjacent to the synchronous process spawn boundary.
+  if (task.stop_requested || task.status !== "running") {
+    await rm(runtimeTempRoot, { recursive: true, force: true }); return task;
+  }
+  if (beforeSpawn) {
+    try { await beforeSpawn(task); }
+    catch (error) {
+      try {
+        if (!task.stop_requested && task.status === "running") {
+          updateTask(task, { status: "failed", control_state: "complete", error: errorMessage(error),
+            reason_code: error.code || "local_task_invocation_authorization_failed", completed_at: new Date().toISOString() });
+          await persist(task);
+        }
+      } finally { await rm(runtimeTempRoot, { recursive: true, force: true }); }
+      return task;
+    }
+  }
+  if (task.stop_requested || task.status !== "running") {
+    await rm(runtimeTempRoot, { recursive: true, force: true }); return task;
+  }
 
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -572,13 +614,20 @@ export async function startLocalTask(
       emitTaskEvent(task, "usage", {
         provider_tokens_used: task.provider_tokens_used,
         provider_token_budget: task.provider_token_budget,
+        continuation_policy: task.continuation_policy || "bounded",
+        provider_token_ceiling: localTaskTokenCeiling(task),
       });
+      if (task.continuation_policy === "progress" && task.provider_tokens_used >= task.provider_token_budget && !task.token_warning_emitted) {
+        task.token_warning_emitted = true;
+        task.warnings.push("Provider token notification threshold reached. Work continues within the approved task and hard safety ceiling.");
+        emitTaskEvent(task, "budget_warning", { provider_tokens_used: task.provider_tokens_used, provider_token_budget: task.provider_token_budget, provider_token_ceiling: localTaskTokenCeiling(task) });
+      }
       if (
-        task.provider_tokens_used > task.provider_token_budget &&
+        localTaskTokensExhausted(task) &&
         !task.stop_requested
       ) {
         task.reason_code = "provider_token_budget_exhausted";
-        task.error = `Provider token budget exceeded (${task.provider_tokens_used} / ${task.provider_token_budget}).`;
+        task.error = `Provider token ${task.continuation_policy === "progress" ? "hard ceiling" : "budget"} exceeded (${task.provider_tokens_used} / ${localTaskTokenCeiling(task)}).`;
         task.stop_requested = true;
         task.control_state = "stopping";
         signalExecutorProcess(child, "SIGINT");
@@ -692,7 +741,7 @@ export async function startLocalTask(
         Boolean(error) ||
         exitCode !== 0 ||
         Boolean(task.error) ||
-        task.provider_tokens_used > task.provider_token_budget;
+        localTaskTokensExhausted(task);
       task.status = manuallyStopped ? "stopped" : failed ? "failed" : "succeeded";
       task.control_state = task.status === "stopped" ? "stopped" : "complete";
       task.error ||= error || (exitCode !== 0 ? `Provider exited with code ${exitCode}.` : null);
@@ -823,6 +872,7 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
     output: [...task.output],
     ...(includeEvents ? { events: structuredClone(task.events) } : {}),
     result: structuredClone(task.result),
+    ...(task.host_verification ? { host_verification: structuredClone(task.host_verification) } : {}),
     artifacts: task.artifacts.map(publicArtifact),
     attachments: task.attachments.map(publicAttachment),
     expected_outputs: structuredClone(task.expected_outputs),
@@ -836,6 +886,9 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
     error: task.error,
     reason_code: task.reason_code,
     provider_token_budget: task.provider_token_budget,
+    continuation_policy: task.continuation_policy || "bounded",
+    provider_token_ceiling: localTaskTokenCeiling(task),
+    token_warning_emitted: task.token_warning_emitted === true,
     provider_tokens_used: task.provider_tokens_used,
     token_usage: structuredClone(task.token_usage),
     ...(task.workflow_observation
@@ -849,6 +902,8 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
     completed_at: task.completed_at,
     ...(includeLocalPaths
       ? {
+          ...(task.purpose_verification ? { purpose_verification: structuredClone(task.purpose_verification),
+            purpose_verification_state: structuredClone(task.purpose_verification_state || null) } : {}),
           workspace_path: task.workspace_path,
           task_root: task.task_root,
           inputs_root: task.inputs_root,
@@ -1057,6 +1112,7 @@ function restoreLocalTask(snapshot) {
   );
   return {
     ...snapshot,
+    ...(snapshot.purpose_verification ? { purpose_verification: normalizePurposeVerification(snapshot.purpose_verification) } : {}),
     outputs_root_expected:
       snapshot.outputs_root_expected || null,
     output: Array.isArray(snapshot.output) ? snapshot.output : [],
@@ -1243,6 +1299,15 @@ function normalizeExpectedOutputs(value) {
     }));
 }
 
+function localTaskTokenCeiling(task) {
+  return task.continuation_policy === "progress" ? normalizeTokenBudget(task.provider_token_ceiling ?? MAX_LOCAL_TASK_TOKEN_BUDGET) : task.provider_token_budget;
+}
+
+function localTaskTokensExhausted(task) {
+  const ceiling = localTaskTokenCeiling(task);
+  return task.continuation_policy === "progress" ? task.provider_tokens_used >= ceiling : task.provider_tokens_used > ceiling;
+}
+
 function normalizeTokenBudget(value) {
   const budget = Number(value ?? DEFAULT_LOCAL_TASK_TOKEN_BUDGET);
   if (!Number.isInteger(budget) || budget < 1 || budget > MAX_LOCAL_TASK_TOKEN_BUDGET) {

package/src/orchestrator/budget.js

@@ -1,4 +1,5 @@
 import { clampAttempts } from "./shared.js";
+import { progressLimits } from "../continuation-policy.js";
 
 export const DEFAULT_TOKEN_BUDGET = 250_000;
 export const DEFAULT_RETRY_BUDGET = 2;
@@ -54,6 +55,31 @@ export function increaseProviderTokenBudget(snapshot, value) {
   return refreshBudgetState(snapshot);
 }
 
+export function extendProgressCeilings(snapshot, changes = {}) {
+  const current = budgetState(snapshot);
+  if (current.continuation_policy !== "progress") {
+    throw new Error("Hard ceilings can be extended only for an explicitly approved progress policy.");
+  }
+  if (!changes || typeof changes !== "object" || Array.isArray(changes) ||
+      Object.keys(changes).some(key => !["provider_token_ceiling", "attempt_ceiling"].includes(key))) {
+    throw new Error("Specify only the Provider token ceiling or attempt ceiling.");
+  }
+  const provided = Object.entries(changes).filter(([, value]) => value !== undefined);
+  if (!provided.length) throw new Error("Explicitly increase at least one hard ceiling.");
+  for (const [field, value] of provided) {
+    const previous = field === "provider_token_ceiling" ? current.hard_token_ceiling : current.hard_attempt_ceiling;
+    const used = field === "provider_token_ceiling" ? current.tokens_used : (snapshot.attempts || []).length;
+    if (!Number.isSafeInteger(value) || value <= previous || value <= used) {
+      throw new Error("Each requested hard ceiling must be an integer higher than its current limit and recorded usage.");
+    }
+  }
+  // Validate every field before changing either ceiling; partial rejection must
+  // never leave a larger authorization behind.
+  const limits = progressLimits({ ...snapshot.charter, ...Object.fromEntries(provided) });
+  for (const [field] of provided) snapshot.charter[field] = limits[field];
+  return refreshBudgetState(snapshot);
+}
+
 export function budgetState(snapshot, pendingAttempt = null) {
   const attempts = [
     ...(Array.isArray(snapshot?.attempts) ? snapshot.attempts : []),
@@ -67,11 +93,15 @@ export function budgetState(snapshot, pendingAttempt = null) {
   const tokensUsed = attempts.reduce(
     (sum, attempt) => sum + tokenUsageTotal(attempt?.token_usage),
     0,
-  );
+  ) + unaccountedProviderUsage(snapshot, attempts);
   const attemptsUsed = attempts.length;
   const retriesUsed = Math.max(attemptsUsed - 1, 0);
-  const tokenExhausted = tokensUsed >= tokenBudget;
-  const retryExhausted = attemptsUsed > 0 && retriesUsed >= retryBudget;
+  const policy = progressLimits(snapshot?.charter);
+  const progress = policy.continuation_policy === "progress";
+  const hardTokenCeiling = progress ? policy.provider_token_ceiling : tokenBudget;
+  const hardAttemptCeiling = progress ? policy.attempt_ceiling : retryBudget + 1;
+  const tokenExhausted = tokensUsed >= hardTokenCeiling;
+  const retryExhausted = attemptsUsed >= hardAttemptCeiling;
   return {
     schema_version: 1,
     token_budget: tokenBudget,
@@ -88,9 +118,26 @@ export function budgetState(snapshot, pendingAttempt = null) {
       : retryExhausted
         ? "retry_budget_exhausted"
         : null,
+    continuation_policy: policy.continuation_policy,
+    token_warning: progress && tokensUsed >= tokenBudget,
+    retry_warning: progress && attemptsUsed >= retryBudget + 1,
+    hard_token_ceiling: hardTokenCeiling,
+    hard_attempt_ceiling: hardAttemptCeiling,
+    hard_tokens_remaining: Math.max(hardTokenCeiling - tokensUsed, 0),
   };
 }
 
+function unaccountedProviderUsage(snapshot, attempts) {
+  const checkpoints = snapshot?.metadata?.provider_usage_checkpoints || {};
+  return Object.entries(checkpoints).reduce((sum, [id, checkpoint]) => {
+    const reported = tokenUsageTotal(checkpoint?.token_usage);
+    const accounted = attempts.reduce((total, attempt) => total + tokenUsageTotal({
+      records: (Array.isArray(attempt?.token_usage?.records) ? attempt.token_usage.records : []).filter(record => record?.invocation_id === id),
+    }), 0);
+    return sum + Math.max(0, reported - accounted);
+  }, 0);
+}
+
 export function refreshBudgetState(snapshot, pendingAttempt = null) {
   const state = budgetState(snapshot, pendingAttempt);
   snapshot.budget = state;
@@ -102,12 +149,16 @@ export function canStartProvider(snapshot, { attemptNumber, phase }) {
   if (state.token_exhausted) {
     return { allowed: false, reason: "token_budget_exhausted", budget: state };
   }
-  if (phase === "executor" && attemptNumber > state.retry_budget + 1) {
+  if (phase === "executor" && attemptNumber > state.hard_attempt_ceiling) {
     return { allowed: false, reason: "retry_budget_exhausted", budget: state };
   }
   return { allowed: true, reason: null, budget: state };
 }
 
+export function codingAttemptCeiling(snapshot) {
+  return snapshot?.charter?.continuation_policy === "progress" ? budgetState(snapshot).hard_attempt_ceiling : snapshot?.charter?.max_attempts;
+}
+
 export function tokenUsageTotal(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
   if (Array.isArray(value.records)) {

package/src/orchestrator/charter-validation.js

@@ -0,0 +1,33 @@
+export function validateCharter(charter) {
+  const findings = [];
+  if (charter.risk.requires_design_review && charter.acceptance_criteria_source !== "explicit") {
+    findings.push({
+      code: "EXPLICIT_ACCEPTANCE_CRITERIA_REQUIRED",
+      severity: "blocker",
+      target: "acceptance_criteria",
+      explanation: "High-risk work requires explicit acceptance criteria.",
+      repairability: "manual",
+    });
+  }
+  if (charter.design_review.required && charter.design_review.status !== "approved") {
+    findings.push({
+      code: "DESIGN_REVIEW_REQUIRED",
+      severity: "blocker",
+      target: "design_review",
+      explanation:
+        "High-risk work requires a design summary, approval owner, and review evidence before implementation.",
+      repairability: "manual",
+    });
+  }
+  if (charter.risk.requires_design_review && charter.required_checks.length === 0) {
+    findings.push({
+      code: "REQUIRED_CI_CHECKS_MISSING",
+      severity: "blocker",
+      target: "required_checks",
+      explanation: "High-risk work requires explicit CI and security check names.",
+      repairability: "manual",
+    });
+  }
+  return findings;
+}
+

package/src/orchestrator/completion-contract.js

@@ -65,7 +65,7 @@ function criterionIds(value, count) {
   if (
     ids.length !== count ||
     new Set(ids).size !== ids.length ||
-    ids.some((id) => !criterionIdPattern.test(id))
+    ids.some((id) => id === "USER-GOAL" || !criterionIdPattern.test(id))
   ) {
     throw new Error("Invalid acceptance criterion IDs");
   }

package/src/orchestrator/contract.js

@@ -8,6 +8,7 @@ import {
   visualEvidenceSurface,
 } from "./shared.js";
 import { budgetState, resolveRunBudgets } from "./budget.js";
+import { progressLimits } from "../continuation-policy.js";
 import { classifyRisk } from "./risk.js";
 import { buildCompletionContract } from "./completion-contract.js";
 import { freezeObjective } from "./outcome-monitor.js";
@@ -117,6 +118,7 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
       max_attempts: budgets.max_attempts,
       retry_budget: budgets.retry_budget,
       token_budget: budgets.token_budget,
+      ...progressLimits(request),
       ui_evidence_root: cleanString(request.ui_evidence_root),
       acceptance_criteria: finalAcceptanceCriteria,
       acceptance_criteria_source: acceptanceCriteriaSource,

package/src/orchestrator/delivery/references/state-and-receipts.md

@@ -99,9 +99,27 @@ recommendation, silence, or an implementation pattern.
 The controller persists `thread_state.objective_contract` with the baseline,
 current version, digest and explicit human revision lineage. Each attempt stores
 `outcome_progress` with its objective digest, independently supported criterion
-IDs, unproven IDs and assessment availability. A repeated unproven set without
-new independently supported IDs opens `OUTCOME_PROGRESS_STALLED`; this prevents
-automatic retries across changing commits. An old review cannot settle a newer
+IDs, unproven IDs and assessment availability. `evaluateOutcomeProgress` separates
+current `verified_ids`, `failed_ids`, and `unassessed_ids`; executor test counts,
+commits, evidence hashes and reference paths cannot create progress. A new
+independently verified criterion resets `no_progress_attempts`. A prior proof
+missing from the current review remains unassessed, rather than silently passing.
+The historical verified-ID set is used only for comparison, so repeating an old
+proof after a regression cannot manufacture new progress.
+
+Progress continuation uses `{ policy: "progress", maxNoProgressAttempts: 3 }`
+with `assessOutcomeProgress`. Three attempts without new verified outcomes,
+including attempts that never reach independent review, mark `stalled` with a
+specific `stall_reason`. The pure evaluator accepts the same threshold for
+Delivery. Legacy runs retain their original stopping policy until the controller
+selects progress continuation. Partial independent proof can show progress even
+when the overall audit fails; a complete passing audit is still required for
+completion. Human and external blockers remain visible alongside machine repairs
+in `blockers` and `next_actions`; they do not imply every criterion is blocked.
+
+Audits bound to a different objective or current candidate evidence identity
+cannot supply progress. Revisions reset the comparison baseline and require a
+fresh independent review. An old review cannot settle a newer
 objective version. Legacy snapshots without an objective contract remain
 readable but lose completion status on restore; their original baseline cannot
 be reconstructed retrospectively. `USER-GOAL` is tracked separately from