@awak-app/simy-cli 0.6.17 → 0.6.19

package/README.md

@@ -86,6 +86,18 @@ and an already consumed remote result prevent automatic recovery. An unfinished
 worker or a missing, invalid or redacted structured result still requires
 reconciliation; no unknown external operation is automatically replayed.
 
+After CI finishes successfully, the authenticated daemon refreshes the independent
+review of the same saved candidate without dispatching its implementation worker.
+The reviewed HEAD, fetched base, objective, preparation evidence and minimum
+completion matrix must still match; changed candidates require explicit work.
+Pending/failing checks, a dirty checkout and missing required checks do not trigger
+this review. Human peer approval remains required when the charter requires it.
+The refreshed review is checked against newly collected evidence before readiness
+can pass. Stop cancels review continuation. A failed or interrupted refresh is not
+repeated on every monitor tick; explicitly continue the same run to recover.
+Older reviews without a saved CI basis can refresh only when their prior evidence
+still establishes the complete reviewed identity; otherwise explicitly continue.
+
 For interrupted Agentic work, `GET /v1/agentic-loop/:id/recovery` provides a
 read-only objective and checkout fingerprint. Reconcile an uncertain side effect
 with `POST` to that endpoint (`action: reconcile`, authoritative
@@ -821,6 +833,11 @@ not a GitHub hook that mechanically intercepts every external close command.
 
 ### Submit repaired local delivery evidence to SQM
 
+The [integrated delivery state model](src/orchestrator/delivery/references/state-model.md)
+connects delivery milestones, repair/wait/resume branches and actual controller
+states. Both executor and auditor receive its path. It documents existing control
+and evidence duties; it adds no scheduler or transition-enforcement mechanism.
+
 The bundled Delivery Loop maintains an external acceptance checklist with separate
 user-journey and technical-invariant results. It refreshes the table after each
 evaluated action and marks evidence pending when the code or runtime context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.17",
+  "version": "0.6.19",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -496,9 +496,8 @@ export async function startAgent({
     return inspection;
   };
 
-  const requireRunProvider = async (run) => {
+  const requireRunProvider = async (run, { backend = run.request.backend } = {}) => {
     const scope = await authorizeDesktopWork();
-    const backend = run.request.backend;
     const inspection = await inspectReadyBackend(backend, { force: true });
     await authorizeDesktopWork(scope);
     await requireLinkedProvider(backend, inspectedLinks.get(inspection));
@@ -507,17 +506,17 @@ export async function startAgent({
         code: `desktop_executor_${inspection.status}`,
       });
     }
-    await bindRunAuthorization(run, scope, inspection);
+    await bindRunAuthorization(run, scope, inspection, backend);
   };
 
   const authorizeProviderDispatch = async (backend, scope, link) => {
     await authorizeDesktopWork(scope);
     await requireLinkedProvider(backend, link);
   };
-  const bindRunAuthorization = async (run, scope, inspection) => {
+  const bindRunAuthorization = async (run, scope, inspection, backend = run.request.backend) => {
     const links = await readProviderLinks(sessionRoot);
-    links[run.request.backend] = inspectedLinks.get(inspection);
-    await authorizeProviderDispatch(run.request.backend, scope, links[run.request.backend]);
+    links[backend] = inspectedLinks.get(inspection);
+    await authorizeProviderDispatch(backend, scope, links[backend]);
     runAuthorizations.set(run, { scope, links });
   };
   const providerRuntimeOptions = (task, options = {}, scope, link) => {
@@ -550,6 +549,22 @@ export async function startAgent({
       executeIndependentAudit: wrap(runOptions.executeIndependentAudit, "SIMY_AUDIT_JSON:") };
   };
 
+  const recheckAuthorizedCodingRun = (run, options = {}) => {
+    const scope = desktopScopeRevision();
+    return recheckLocalCodingRun(run, { collectEvidence: runOptions.collectEvidence, ...options,
+      executeIndependentAudit: context => withUpdateWork(updateManager,
+        () => codingRuntimeOptions(run).executeIndependentAudit(context)),
+      authorizeReview: async () => {
+        await authorizeDesktopWork(scope);
+        if (!isSessionValid(session, Date.now(), apiOrigin) || !sameRunScope(run.session, session)) {
+          throw new Error("The original authorized coding run session changed.");
+        }
+        await requireRunProvider(run, { backend: run.snapshot.charter.audit_backend });
+        await authorizeDesktopWork(scope);
+      },
+    });
+  };
+
   let organizationCancellation = Promise.resolve();
   const suspendOrganizationWork = () => {
     durableLocalTaskWorker?.pause?.();
@@ -796,7 +811,7 @@ export async function startAgent({
       for (const run of registry.list()) {
         if (!["pr_ready_for_review", "merge_ready"].includes(run.status) || run.operation || run.child) continue;
         try {
-          await (dependencies.recheckCodingRun || recheckLocalCodingRun)(run);
+          await (dependencies.recheckCodingRun || recheckAuthorizedCodingRun)(run);
         } catch (error) {
           await markCodingRunMonitorFailure(run, error);
         }
@@ -2538,7 +2553,7 @@ export async function startAgent({
           json(res, 409, { error: "run is not ready for PR evidence recheck" });
           return;
         }
-        const snapshot = await recheckLocalCodingRun(run);
+        const snapshot = await recheckAuthorizedCodingRun(run);
         json(res, 200, { ok: true, run_id: run.id, state: snapshot.state });
         return;
       }
@@ -2792,6 +2807,12 @@ export async function startAgent({
           !Number.isFinite(ticket.expiresAt) || ticket.expiresAt <= Date.now() || ticket.expiresAt > Date.now() + 60_000) throw new Error("Desktop sign-in changed");
       return { code: ticket.code, expiresAt: ticket.expiresAt, userId: ticket.userId, orgSlug: ticket.orgSlug };
     },
+    // This is an in-process capability for the native host. It is deliberately
+    // absent from status frames and never written to disk by the host.
+    getLocalCliApiSession() {
+      if (!isSessionValid(session, Date.now(), apiOrigin) || pendingOrganization) return null;
+      return { token: session.token, api_base_url: session.api_base_url };
+    },
     getDesktopStatus,
     stopDesktopTask,
     stopDesktopTasks,
@@ -2912,7 +2933,7 @@ export async function startAgent({
       recheck: (run) =>
         withUpdateWork(updateManager, async () => {
           await authorizeDesktopWork();
-          return recheckLocalCodingRun(run, { collectEvidence: runOptions.collectEvidence });
+          return recheckAuthorizedCodingRun(run, { collectEvidence: runOptions.collectEvidence });
         }),
     },
   };

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.6.17";
+export const CLI_VERSION = "0.6.19";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -8,6 +8,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { acquireWorkspaceLease, releaseWorkspaceLease } from './workspace-lease.mjs';
 import { associationContract, validateAssociationResult } from './action-association.mjs';
+import { minimalSufficientChangeInstruction } from './minimal-sufficient.mjs';
 import { continuationMode } from './continuation-policy.mjs';
 import { evaluateOutcomeProgress, restartOutcomeProgressWindow } from './outcome-progress.mjs';
 
@@ -318,10 +319,10 @@ export function evaluateAssessedPlan(plan, policy, scopes, now = Date.now()) {
 // Shared by live Stop hooks and cold exact-session recovery. Keep the result
 // contract identical across transports; the host still verifies acceptance.
 export function assessedCheckpointContract(decision) {
-  return `Return ONLY one JSON object with top-level status:"in_progress|completed|blocked|error" and summary:"what happened". Use the key status, NEVER kind, for an ordinary work checkpoint. Record actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"what actually happened",evidence:["concrete observation"]} for THIS selected action. This is provider-reported, not independent verification. For in_progress/error include nextStep, remainingWork, and plan:{diagnosis,alternatives:[{id,action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification,rollback}],selectedOptionId,recommendation:{optionId,reason},userQuestion?} for the NEXT action; select one assessed option but do not execute it in this turn. Valid action.kind values are exactly read, local_edit, local_test, external, destructive, scope_change, unknown; use local_edit for writing local files. Risk is low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown. Missing facts are unknown. Completed requires evidence, and SIMY independently checks frozen acceptance. Blocked requires blocker set to exactly authorization, missing_information, or external_dependency, plus nextStep. For authorization, include an assessed plan and set approval to an exact copy of the selected plan alternative action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. missing_information requires a specific question. external_dependency requires waitCondition:{condition,owner,nextCheck} with the observable resumption condition, dependency owner, and bounded recheck instruction, plus nextStep.`;
+  return `${minimalSufficientChangeInstruction({ turn: 'assessed' })}\nReturn ONLY one JSON object with top-level status:"in_progress|completed|blocked|error" and summary:"what happened". Use the key status, NEVER kind, for an ordinary work checkpoint. Record actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"what actually happened",evidence:["concrete observation"]} for THIS selected action. This is provider-reported, not independent verification. For in_progress/error include nextStep, remainingWork, and plan:{diagnosis,alternatives:[{id,action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification,rollback}],selectedOptionId,recommendation:{optionId,reason},userQuestion?} for the NEXT action; select one assessed option but do not execute it in this turn. Valid action.kind values are exactly read, local_edit, local_test, external, destructive, scope_change, unknown; use local_edit for writing local files. Risk is low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown. Missing facts are unknown. Completed requires evidence, and SIMY independently checks frozen acceptance. Blocked requires blocker set to exactly authorization, missing_information, or external_dependency, plus nextStep. For authorization, include an assessed plan and set approval to an exact copy of the selected plan alternative action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. missing_information requires a specific question. external_dependency requires waitCondition:{condition,owner,nextCheck} with the observable resumption condition, dependency owner, and bounded recheck instruction, plus nextStep.`;
 }
 export function understandingCheckpointContract(decision) {
-  return `This is an UNDERSTANDING turn, not a work turn. Read the existing conversation context and available read-only evidence; do not edit files, call external services, or start the proposed next action. Return ONLY JSON {kind:"session_understanding",summary:"...",actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"...",evidence:["..."]},sessionUnderstanding:{state:"clear|ambiguous|context_missing|already_done",objective:"current user goal",constraints:["..."],done:["..."],remaining:["..."],nextAction:{kind:"read|local_edit|local_test|external|destructive|scope_change|unknown",scope:"task",summary:"..."},criteria:[{description:"...",source:"user_grounded|proposed",basisIndex:0,check:{type:"manual|file_exists|file_contains|file_equals",path:"relative/path",text:"expected text"}}],ambiguities:["..."],question:"one focused user question if unclear",basis:[{source:"user|assistant|artifact",turnRef:"if available",snippet:"short relevant excerpt"}]},plan:{diagnosis:"...",alternatives:[{id:"...",action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification:"...",rollback:"..."}],selectedOptionId:"...",recommendation:{optionId:"...",reason:"..."}}}. For clear, choose one NEXT action but do not execute it. Set sessionUnderstanding.nextAction to an exact copy of the selected plan alternative's action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. Complete every known assessment field: risk low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown; inObjective and userChoice booleans. For a read-only single-file action with no effects, use reversible, none, single_file when those facts are known; unknown facts require review. Use only the original user's goal; constraints[] must contain only constraints from the original user, not these SIMY turn instructions. Do not invent new work or acceptance obligations. Include a user-grounded criterion only with a basisIndex pointing to a user message. Use file_equals for a user-requested file whose complete UTF-8 contents must be exact (including whitespace/newlines), file_contains only for a requested substring, and file_exists only for existence. For semantic conditions use manual. If the complete expected file contents are not yet known from the original user request or observed evidence in this understanding turn, use manual for that criterion and choose a read as the next action to learn them. Never emit file_equals with null, omitted, guessed, or placeholder text; an exact file check requires a bounded concrete UTF-8 string now. Do not perform the proposed next action merely to fill the check, and do not claim that a later read or model report has independently verified a manual criterion. Do not invent a file check from repository hints alone. If the original work is already done, choose already_done with remaining:[], nextAction:null, no plan, and no new goal. If material context is missing, set exactly one ambiguity and one focused question, nextAction:null, and omit plan. Provider statements about past work and semantic success are not independent verification. Optionally include sessionUnderstanding.matchingContext:{deliverables:["concrete requested output"],projectHints:["project name"],repositoryUrls:[],relatedUrls:[],actionIds:[],sourceRefs:[{platform:"slack",externalThreadId:"exact thread",channelExternalId:"exact channel"}]}. Extract only explicit conversation evidence; IDs and sources are retrieval signals, never authenticated identity. Do not infer URLs or identifiers.`;
+  return `${minimalSufficientChangeInstruction({ turn: 'understanding' })}\nThis is an UNDERSTANDING turn, not a work turn. Read the existing conversation context and available read-only evidence; do not edit files, call external services, or start the proposed next action. Return ONLY JSON {kind:"session_understanding",summary:"...",actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"...",evidence:["..."]},sessionUnderstanding:{state:"clear|ambiguous|context_missing|already_done",objective:"current user goal",constraints:["..."],done:["..."],remaining:["..."],nextAction:{kind:"read|local_edit|local_test|external|destructive|scope_change|unknown",scope:"task",summary:"..."},criteria:[{description:"...",source:"user_grounded|proposed",basisIndex:0,check:{type:"manual|file_exists|file_contains|file_equals",path:"relative/path",text:"expected text"}}],ambiguities:["..."],question:"one focused user question if unclear",basis:[{source:"user|assistant|artifact",turnRef:"if available",snippet:"short relevant excerpt"}]},plan:{diagnosis:"...",alternatives:[{id:"...",action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification:"...",rollback:"..."}],selectedOptionId:"...",recommendation:{optionId:"...",reason:"..."}}}. For clear, choose one NEXT action but do not execute it. Set sessionUnderstanding.nextAction to an exact copy of the selected plan alternative's action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. Complete every known assessment field: risk low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown; inObjective and userChoice booleans. For a read-only single-file action with no effects, use reversible, none, single_file when those facts are known; unknown facts require review. Use only the original user's goal; constraints[] must contain only constraints from the original user, not these SIMY turn instructions. Do not invent new work or acceptance obligations. Include a user-grounded criterion only with a basisIndex pointing to a user message. Use file_equals for a user-requested file whose complete UTF-8 contents must be exact (including whitespace/newlines), file_contains only for a requested substring, and file_exists only for existence. For semantic conditions use manual. If the complete expected file contents are not yet known from the original user request or observed evidence in this understanding turn, use manual for that criterion and choose a read as the next action to learn them. Never emit file_equals with null, omitted, guessed, or placeholder text; an exact file check requires a bounded concrete UTF-8 string now. Do not perform the proposed next action merely to fill the check, and do not claim that a later read or model report has independently verified a manual criterion. Do not invent a file check from repository hints alone. If the original work is already done, choose already_done with remaining:[], nextAction:null, no plan, and no new goal. If material context is missing, set exactly one ambiguity and one focused question, nextAction:null, and omit plan. Provider statements about past work and semantic success are not independent verification. Optionally include sessionUnderstanding.matchingContext:{deliverables:["concrete requested output"],projectHints:["project name"],repositoryUrls:[],relatedUrls:[],actionIds:[],sourceRefs:[{platform:"slack",externalThreadId:"exact thread",channelExternalId:"exact channel"}]}. Extract only explicit conversation evidence; IDs and sources are retrieval signals, never authenticated identity. Do not infer URLs or identifiers.`;
 }
 function boundedContextList(value, maxItems = 8, maxLength = 300) {
   if (!Array.isArray(value) || value.length > maxItems) throw new Error('Session understanding has too many items.');
@@ -1030,7 +1031,7 @@ export function decideStop(run, now = Date.now()) {
   }
   next.reason = fresh ? 'continue_pending_work' : 'checkpoint_missing';
   const selected = next.managed?.autonomyPolicy ? next.managed.decision : null;
-  const instruction = selected && next.managed.phase === 'action_association' ? `${associationContract(next.managed.actionAssociation.job)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping.` : selected && next.managed.phase === 'understanding' ? `Understand the current user request in this ORIGINAL conversation. ${next.managed.understandingAnswer ? `The user answered question ${next.managed.understandingAnswer.questionId}: ${next.managed.understandingAnswer.text}. ` : ''}${understandingCheckpointContract(selected)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable. This updates SIMY metadata only; do not create a checkpoint file in the task workspace.` : selected ? `${initialHook ? `Managed objective: ${next.objective}. Frozen acceptance criteria: ${JSON.stringify(next.managed.acceptanceCriteria)}. ` : ''}${replanHook ? `Replan context: ${next.managed.plan.diagnosis}. ` : ''}Execute only selected ${selected.action.kind} action in scope ${selected.action.scope}: ${selected.action.summary}. Expected verification: ${selected.expectedVerification}. Rollback: ${selected.rollback || 'none needed'}. ${assessedCheckpointContract(selected)} Submit that JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable; do not create a task-workspace checkpoint file.` : fresh ? next.nextStep : `Check the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
+  const instruction = selected && next.managed.phase === 'action_association' ? `${associationContract(next.managed.actionAssociation.job)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping.` : selected && next.managed.phase === 'understanding' ? `Understand the current user request in this ORIGINAL conversation. ${next.managed.understandingAnswer ? `The user answered question ${next.managed.understandingAnswer.questionId}: ${next.managed.understandingAnswer.text}. ` : ''}${understandingCheckpointContract(selected)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable. This updates SIMY metadata only; do not create a checkpoint file in the task workspace.` : selected ? `${initialHook ? `Managed objective: ${next.objective}. Frozen acceptance criteria: ${JSON.stringify(next.managed.acceptanceCriteria)}. ` : ''}${replanHook ? `Replan context: ${next.managed.plan.diagnosis}. ` : ''}Execute only selected ${selected.action.kind} action in scope ${selected.action.scope}: ${selected.action.summary}. Expected verification: ${selected.expectedVerification}. Rollback: ${selected.rollback || 'none needed'}. ${assessedCheckpointContract(selected)} Submit that JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable; do not create a task-workspace checkpoint file.` : fresh ? `${minimalSufficientChangeInstruction()}\n${next.nextStep}` : `${minimalSufficientChangeInstruction()}\nCheck the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
   return { run: next, output: { decision: 'block', reason: `SIMY Delivery Loop (${next.continuations} continuations). ${next.executionCwd ? `Use task execution directory ${JSON.stringify(next.executionCwd)} for task work and acceptance. ` : ''}${deliveryAcceptanceContext(next)} ${instruction}\nStay within the original request and permissions. If authorization or information is missing, record a blocked checkpoint and stop. Resume this same task; do not start a replacement loop.` } };
 }
 // A process signature protects against PID reuse. Never treat a stale timer alone

package/src/codex-plugins/simy/hooks/minimal-sufficient.mjs

@@ -0,0 +1,15 @@
+export function minimalSufficientChangeInstruction({ auditor = false, turn = 'implementation' } = {}) {
+  return [
+    turn === 'understanding'
+      ? "For planning only, propose the smallest change sufficient for the original purpose and acceptance criteria. Explain which criterion or observed failure each proposed behavior, abstraction, configuration, compatibility branch, document or test would serve."
+      : "Choose the smallest change sufficient for the original purpose and acceptance criteria. Explain which criterion or observed failure each substantive behavior, abstraction, configuration, compatibility branch, document or test serves.",
+    "Prefer existing conventions and a simpler equivalent. Avoid speculative features, generalization, duplicate implementations and repetitive prose or tests. Do not optimize line counts or remove required behavior, authorization, data integrity, concurrency, failure recovery, regression coverage or evidence to make a change shorter.",
+    auditor
+      ? "Independently inspect the final diff for unnecessary scope and complexity. Report concrete findings with file/line, harm or maintenance burden, a smaller alternative, preserved criteria and required verification; do not invent findings when the change is already sufficient."
+      : turn === 'understanding'
+        ? "Use read-only evidence to plan; do not inspect the final diff as a completion step or perform cleanup in this understanding turn. Record any cleanup proposal for a next assessed action, without executing it."
+        : turn === 'assessed'
+          ? "Execute only the selected decision.action. Cleanup is allowed only when explicitly included in that selected action and within its scope, expected verification and rollback. Defer any additional diff inspection or cleanup: report it in the existing checkpoint or propose it as the next assessed action, without executing it in this turn. Summarize the selected action's sufficiency in the existing result; a plan or reduced diff is not proof of acceptance."
+          : "Before completion, inspect the final diff against the original purpose and remove unnecessary scope or complexity only when required behavior and verification remain intact. Summarize that judgment in the existing result; a plan or reduced diff is not proof of acceptance.",
+  ].join("\n");
+}

package/src/delivery-hooks/supervisor.js

@@ -1,3 +1,4 @@
+import { minimalSufficientChangeInstruction } from '../codex-plugins/simy/hooks/minimal-sufficient.mjs';
 import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
@@ -83,7 +84,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     remainingWork: run.managed.remainingWork, acceptanceCriteria: run.managed.acceptanceCriteria, proposedAction: run.managed.proposedAction,
     currentDecision: run.managed.autonomyPolicy ? run.managed.decision : undefined, diagnosis: run.managed.plan?.diagnosis,
     progress: deliveryProgressContext(run) };
-  const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
+  const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\n${minimalSufficientChangeInstruction()}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
   const sandbox = run.managed.autonomyPolicy && run.managed.decision?.action.kind === 'read' ? 'read-only' : run.managed.autoRecoverySandbox;
   const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-m', run.managed.resumeModel, 'resume', record.session, prompt];
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');

package/src/desktop-access.js

@@ -12,7 +12,8 @@ const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization
   'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
 export function desktopActionAllowed(access, command) {
   return desktopAccessReady(access) || recoveryActions.has(command?.action) ||
-    command?.action === 'session_set_auto_continue' && command.enabled === false;
+    command?.action === 'session_set_auto_continue' && command.enabled === false ||
+    command?.action === 'session_set_email_reports' && command.enabled === false;
 }
 export function requireDesktopAccess(access) {
   if (!desktopAccessReady(access)) throw Object.assign(new Error('Sign in to an organization with SQM and Developer access before using SIMY.'), { code: 'desktop_access_required' });

package/src/desktop-host.js

@@ -37,6 +37,8 @@ import { openAuthorizationUrl } from "./browser.js";
 import { inspectBackendExecutable } from "./backend-executable.js";
 import { inspectSqmAgentSkill } from "./sqm/agent-skill.js";
 import { startWorkflowUpdates, syncInstalledWorkflows } from "./sqm/workflow-update.js";
+import { createNativeDevelopmentReportsApi, normalizeNativeDevelopmentReportSave } from "./native-development-reports.js";
+import { projectNativeDevelopmentReportCompletion, sendNativeDevelopmentReportCompletion } from "./native-development-report-completion.js";
 import {
   acquireDesktopProcessLock,
   assertNoLegacyCliDaemon,
@@ -147,10 +149,30 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let statisticsSelection = { key: null, generation: 0 };
   const stopNotifier = createStopNotifier({ emit: event => { if (!closed && !relay) emit(event); } });
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
+  let nativeDevelopmentReports = { state: 'loading', enrollments: [] };
+  let nativeDevelopmentReportsScope = null;
+  let nativeDevelopmentReportsRequest = null;
+  let nativeDevelopmentReportsGeneration = 0;
+  let nativeDevelopmentReportsRetryAt = 0;
+  let nativeDevelopmentReportsMutation = false;
+  const nativeCompletionSuccess = new Set();
+  const nativeCompletionRejected = new Set();
+  const nativeCompletionInFlight = new Map();
+  const nativeCompletionRetryAt = new Map();
   const accessScope = access => JSON.stringify([access?.revision ?? null, access?.organizationId ?? null]);
   const setAccessSnapshot = async access => {
     const previousScope = accessScope(currentAccess);
+    const previouslyReady = desktopAccessReady(currentAccess);
     currentAccess = access || { state: 'unavailable', organizationId: null, organizationName: null };
+    if (previousScope !== accessScope(currentAccess) || previouslyReady && !desktopAccessReady(currentAccess)) {
+      // A privilege loss also invalidates consent reads, even when the
+      // credential/organization revision itself did not change.
+      nativeDevelopmentReports = { state: 'loading', enrollments: [] };
+      nativeDevelopmentReportsScope = null;
+      nativeDevelopmentReportsGeneration++;
+      nativeDevelopmentReportsRetryAt = 0;
+      nativeCompletionInFlight.clear();
+    }
     if (previousScope !== accessScope(currentAccess)) {
       statisticsCache.clear();
       activeStatisticsRead?.controller.abort();
@@ -201,6 +223,76 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const failure = results.find(result => result.status === 'rejected');
     if (failure) throw failure.reason;
   };
+  const localCliApiSession = () => dependencies.getLocalCliApiSession?.() || agent?.getLocalCliApiSession?.() || null;
+  const nativeReportsApi = (fixedSession = null) => (dependencies.createNativeDevelopmentReportsApi || createNativeDevelopmentReportsApi)({
+    webOrigin,
+    readSession: async () => fixedSession || localCliApiSession(),
+    fetchImpl: dependencies.fetch || globalThis.fetch,
+  });
+  const refreshNativeDevelopmentReports = async ({ force = false } = {}) => {
+    if (!desktopAccessReady(currentAccess)) return nativeDevelopmentReports;
+    if (nativeDevelopmentReportsMutation) return nativeDevelopmentReports;
+    const requestedScope = accessScope(currentAccess);
+    if (!force && nativeDevelopmentReportsScope === requestedScope && nativeDevelopmentReports.state === 'ready') return nativeDevelopmentReports;
+    if (!force && Date.now() < nativeDevelopmentReportsRetryAt) return nativeDevelopmentReports;
+    if (nativeDevelopmentReportsRequest?.scope === requestedScope) return nativeDevelopmentReportsRequest.promise;
+    nativeDevelopmentReports = { state: 'loading', enrollments: nativeDevelopmentReportsScope === requestedScope ? nativeDevelopmentReports.enrollments : [] };
+    nativeDevelopmentReportsScope = requestedScope;
+    const generation = nativeDevelopmentReportsGeneration;
+    const job = { scope: requestedScope, generation, promise: null };
+    job.promise = nativeReportsApi().list().then(enrollments => {
+      if (accessScope(currentAccess) === requestedScope && nativeDevelopmentReportsGeneration === generation) {
+        nativeDevelopmentReports = { state: 'ready', enrollments };
+        nativeDevelopmentReportsRetryAt = 0;
+      }
+      return nativeDevelopmentReports;
+    }).catch(() => {
+      if (accessScope(currentAccess) === requestedScope && nativeDevelopmentReportsGeneration === generation) {
+        nativeDevelopmentReports = { state: 'unavailable', enrollments: [] };
+        nativeDevelopmentReportsRetryAt = Date.now() + 30_000;
+      }
+      return nativeDevelopmentReports;
+    }).finally(() => {
+      if (nativeDevelopmentReportsRequest === job) nativeDevelopmentReportsRequest = null;
+      if (!closed && !relay) void publish().catch(() => {});
+    });
+    nativeDevelopmentReportsRequest = job;
+    return job.promise;
+  };
+  const submitNativeDevelopmentReportCompletions = ({ records, scope, deviceSession }) => {
+    if (!deviceSession?.token || !deviceSession?.api_base_url || nativeDevelopmentReports.state !== "ready" || nativeDevelopmentReportsScope !== scope) return;
+    const generation = nativeDevelopmentReportsGeneration;
+    for (const enrollment of nativeDevelopmentReports.enrollments) {
+      if (enrollment.provider !== "codex" || enrollment.enabled !== true) continue;
+      const record = records.find(item => item.provider === enrollment.provider && item.session?.toLowerCase() === enrollment.provider_session_id?.toLowerCase());
+      const completion = projectNativeDevelopmentReportCompletion({ enrollment, record });
+      if (!completion) continue;
+      const key = [scope, completion.provider, completion.provider_session_id, completion.task_id, completion.enrollment_revision, completion.managed_revision, completion.acceptance_digest].join(":");
+      // A terminal response is tied to the consent identity, rather than a
+      // particular proof revision: a new consent revision is required before
+      // the desktop may offer that server a different attestation.
+      const rejectionKey = [scope, completion.provider, completion.provider_session_id, completion.task_id, completion.enrollment_revision].join(":");
+      if (nativeCompletionSuccess.has(key) || nativeCompletionRejected.has(rejectionKey) || nativeCompletionInFlight.has(key) || Date.now() < (nativeCompletionRetryAt.get(key) || 0)) continue;
+      const job = Promise.resolve().then(async () => {
+        if (closed || relay || nativeDevelopmentReportsGeneration !== generation || accessScope(currentAccess) !== scope) return null;
+        const receipt = await sendNativeDevelopmentReportCompletion({ api: nativeReportsApi(deviceSession), enrollment, record });
+        if (receipt && nativeDevelopmentReportsGeneration === generation && accessScope(currentAccess) === scope) {
+          nativeCompletionSuccess.add(key);
+          nativeCompletionRetryAt.delete(key);
+        }
+        return receipt;
+      }).catch(error => {
+        if (nativeDevelopmentReportsGeneration === generation && accessScope(currentAccess) === scope) {
+          // These are immutable authorization/contract rejections. A new
+          // enrollment revision or scope produces a fresh rejection identity.
+          if ([400, 403, 409].includes(error?.status)) nativeCompletionRejected.add(rejectionKey);
+          else nativeCompletionRetryAt.set(key, Date.now() + 30_000);
+        }
+        return null;
+      }).finally(() => nativeCompletionInFlight.delete(key));
+      nativeCompletionInFlight.set(key, job);
+    }
+  };
   let organizationAnalysesSuspended = false;
   let organizationAnalysisDrain = Promise.resolve();
   let organizationAnalysisEpoch = 0;
@@ -482,6 +574,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
         ? structuredClone(lastStatus.deliveryHooks) : { runs: [], providers: {} };
       status.sessionSupervision = sameScope && lastStatus?.sessionSupervision
         ? structuredClone(lastStatus.sessionSupervision) : { sessions: [], providers: {}, refreshedAt: null, initialLoading: desktopAccessReady(currentAccess) };
+      // Complete fast frames must retain the current saved preference so OFF
+      // remains available while unrelated conversation enrichment is waiting.
+      status.nativeDevelopmentReports = sameScope && nativeDevelopmentReportsScope === accessScope(currentAccess)
+        ? structuredClone(nativeDevelopmentReports) : { state: 'loading', enrollments: [] };
       // Cached enrichment must follow the current connection preference even
       // while a full projection is waiting on records or remote metadata.
       status.deliveryHooks.runs = linkedSessions(status.deliveryHooks.runs || []);
@@ -538,10 +634,24 @@ export async function startDesktopHost({ input = process.stdin, output = process
         status.sessionSupervision = { sessions: [], providers: {}, refreshedAt: null };
         if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks) { publishAgain = true; return; }
         if (connectionRevision !== requestedConnectionRevision || !sameAccess(sampledAccess, agent?.getDesktopAccess ? agent.getDesktopAccess() : await readAccess())) { publishAgain = true; return; }
+        status.nativeDevelopmentReports = { state: 'loading', enrollments: [] };
         if (!closed && !relay) emitStatus(status);
         return;
       }
       await analysisManager.updateProviderStatuses?.(status.providers);
+      // Listing only reads rows previously registered by this device/account/org;
+      // it never passes the locally discovered catalog to Web.
+      if (agent.getLocalCliApiSession || dependencies.getLocalCliApiSession) {
+        void refreshNativeDevelopmentReports();
+      }
+      status.nativeDevelopmentReports = structuredClone(nativeDevelopmentReports);
+      // This is an asynchronous local attestation. It neither changes a
+      // Delivery Loop nor places receipt or device data in status frames.
+      submitNativeDevelopmentReportCompletions({
+        records: allRecords,
+        scope: requestedScope,
+        deviceSession: localCliApiSession(),
+      });
       stopNotifier.observe(records);
       const projection = await actionAssociations.beginProjection?.({ records });
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
@@ -1080,6 +1190,92 @@ export async function startDesktopHost({ input = process.stdin, output = process
           // forced request could invalidate a concurrent manual recommendation.
           void publish().catch(() => {});
           return;
+        } else if (action === "session_set_email_reports") {
+          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether development report emails are enabled.');
+          if (command.enabled) {
+            if (command.provider !== 'codex') throw new Error('Development report email is not available for this provider yet.');
+            // Initial consent binds only to a currently observed local session.
+            // The title remains caller-provided; the host never reads transcript
+            // content to populate it.
+            await selectedSession(command, { preferObserved: true });
+          }
+          if (command.enabled) await authorizeWork(commandScope);
+          // Validate before the recovery path: an invalid local command is not
+          // an ambiguous remote write and must never be accepted from a list.
+          const request = normalizeNativeDevelopmentReportSave({
+            provider: command.provider,
+            provider_session_id: command.session,
+            request_title: command.requestTitle,
+            enabled: command.enabled,
+            expected_revision: command.expectedRevision,
+          });
+          const deviceSession = localCliApiSession();
+          if (!deviceSession) throw new Error('SIMY desktop sign-in is required.');
+          // Keep the credential tuple fixed across PUT and its readback. A
+          // changed account/device scope must fail instead of confirming one
+          // user’s write with another user’s registry.
+          const reportsApi = nativeReportsApi(deviceSession);
+          const sameIdentity = enrollment => enrollment.provider === request.provider &&
+            enrollment.provider_session_id === String(request.provider_session_id || '').toLowerCase();
+          const matchesSaved = enrollment => sameIdentity(enrollment) && enrollment.enabled === request.enabled &&
+            (!request.enabled || enrollment.request_title === String(request.request_title || '').trim());
+          const confirmed = enrollments => request.enabled
+            ? enrollments.some(matchesSaved)
+            : !enrollments.some(sameIdentity) || enrollments.some(matchesSaved);
+          const mutationGeneration = ++nativeDevelopmentReportsGeneration;
+          nativeDevelopmentReportsMutation = true;
+          let recoveredCurrent = false;
+          const invalidateMutation = () => {
+            if (nativeDevelopmentReportsGeneration !== mutationGeneration || accessScope(currentAccess) !== commandScope) return;
+            nativeDevelopmentReports = { state: 'unavailable', enrollments: [] };
+            nativeDevelopmentReportsRetryAt = Date.now() + 30_000;
+          };
+          try {
+            try {
+              await reportsApi.save(request);
+            } catch (error) {
+            // The server may have committed before a connection failure. Read
+            // back the device-scoped registry before reporting an error.
+            const recovered = await reportsApi.list().catch(() => null);
+            if (!recovered) {
+              invalidateMutation();
+              throw error;
+            }
+            // A conflict contains useful current revision state. Publish it so
+            // the next explicit choice starts from the server's revision.
+            if (nativeDevelopmentReportsGeneration === mutationGeneration && accessScope(currentAccess) === commandScope) {
+              nativeDevelopmentReports = { state: 'ready', enrollments: recovered };
+              nativeDevelopmentReportsRetryAt = 0;
+              recoveredCurrent = true;
+            }
+              if (!confirmed(recovered)) throw error;
+            }
+            const enrollments = await reportsApi.list();
+            if (!confirmed(enrollments)) throw new Error('Development report email settings could not be confirmed.');
+            if (command.enabled) await authorizeWork(commandScope);
+            const currentDeviceSession = localCliApiSession();
+            if (!currentDeviceSession || currentDeviceSession.token !== deviceSession.token || currentDeviceSession.api_base_url !== deviceSession.api_base_url) {
+              throw Object.assign(new Error('Desktop account or organization changed.'), { code: 'desktop_access_required' });
+            }
+            if (nativeDevelopmentReportsGeneration !== mutationGeneration) throw new Error('Development report email settings changed; refresh and try again.');
+            nativeDevelopmentReportsScope = accessScope(currentAccess);
+            nativeDevelopmentReports = { state: 'ready', enrollments };
+            nativeDevelopmentReportsRetryAt = 0;
+            // Fence a GET that was in flight before this completed mutation.
+            nativeDevelopmentReportsGeneration++;
+            emit({ type: "result", id: command.id, ok: true });
+            void publish().catch(() => {});
+            return;
+          } catch (error) {
+            // A completed PUT without a confirmable readback must not leave a
+            // prior ready revision cached forever. Preserve a 409 readback,
+            // which is itself the current server state.
+            if (!recoveredCurrent) invalidateMutation();
+            throw error;
+          } finally {
+            nativeDevelopmentReportsMutation = false;
+            if (!closed && !relay) void publish().catch(() => {});
+          }
         } else if (action === "session_deadline_decide") {
           if (command.cancel === true) { emit({ type: "result", id: command.id, ok: true }); return; }
           const candidate = await selectedSession(command);
@@ -1150,7 +1346,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       void execute();
     } else if (command.action === "my_ai_session") {
       myAiSessionQueue = myAiSessionQueue.then(execute).catch(() => {});
-    } else if (command.action === "session_set_auto_continue") {
+    } else if (["session_set_auto_continue", "session_set_email_reports"].includes(command.action)) {
       preferenceQueue = preferenceQueue.then(execute).catch(() => {});
     } else if (command.action === 'session_statistics') {
       void execute();