@awak-app/simy-cli 0.7.0 → 0.7.1

package/README.md

@@ -1042,6 +1042,12 @@ remaining task findings. `runtime legacy-hooks` routes only the exact shipped
 customized hooks and trust settings remain unchanged. `runtime workflows` refreshes
 existing provider workflows without enabling them.
 
+`runtime doctor` also returns `taskReadiness` for every existing task: its original
+ID/state, configuration compatibility or pending migration, and the reason work is
+queued or waiting. `current` describes configuration only; it does not certify a
+worker execution, successful repair, or acceptance. User stops and OFF remain
+visible rather than being counted as migration failures.
+
 For existing opted-in Codex tasks, the controller verifies original session, cwd,
 model, provider link and consent epoch before an idempotent policy migration.
 Frozen goal, criteria, grants, budgets and failure history are retained. Observable
@@ -1058,6 +1064,13 @@ recorded; an audit receipt does not complete a task. SQM evidence stays bound to
 repository/commit/diff scope and does not prove the whole user outcome. Git output
 no longer uses a 10 MiB `execFile` buffer; the full diff is still retained in memory.
 
+If a later audit finds unmet work while an earlier review was waiting only for
+human acceptance, the controller reopens independent inspection of the durable
+findings. Confirmed gaps return to diagnosis, authorized repair and reinspection;
+incorrect findings need captured counterevidence to be refuted. Restarting the host
+retains this handoff, task identity and budgets. Actual human acceptance is never
+supplied by the repair loop, and unresolved native permissions are preserved.
+
 Codex cold recovery and independent audit are supported. Claude retains its
 original live-hook boundary; cold recovery and detached independent audit are not
 implemented in this release and are exposed as a capability gap. Neither an

package/package.json

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

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.7.0";
+export const CLI_VERSION = "0.7.1";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/delivery-hooks/command.js

@@ -1,6 +1,6 @@
 import { diagnoseDelivery } from './diagnosis.js';
 import { linkSessionParent } from '../session-supervision/session-lineage.js';
-import { adoptAutonomousPolicy } from '../session-supervision/autonomous-upgrade.js';
+import { adoptAutonomousPolicy, autonomousTaskReadiness } from '../session-supervision/autonomous-upgrade.js';
 import { deliveryEvidence } from './evidence.js';
 import { readFile } from 'node:fs/promises';
 import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory, verifyDelivery, readRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
@@ -80,7 +80,8 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
     if (args[0] === 'doctor') {
       const [runtime, host, monitor, records] = await Promise.all([localRuntimeStatus({ root: dirname(root), allowMissingLock: true }),
         desktopRuntimeStatus({ root: dirname(root) }), consistencyMonitorStatus(root), listRecords(root)]);
-      output(JSON.stringify({ runtime, host, monitor, tasks: records.flatMap(record => consistencyFindings(record)) }, null, 2)); return 0;
+      output(JSON.stringify({ runtime, host, monitor, tasks: records.flatMap(record => consistencyFindings(record)),
+        taskReadiness: records.map(record => autonomousTaskReadiness(record)) }, null, 2)); return 0;
     }
     const result = args[0] === 'workflows' ? await syncInstalledWorkflows({ installMissing: false })
       : await (args[0] === 'install' ? installLocalRuntime : localRuntimeStatus)({ root: dirname(root), ...(args[0] === 'status' ? { allowMissingLock: true } : {}) });

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

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason } 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';
 
@@ -28,6 +28,34 @@ export function policyAdoptionPending(record) {
     (m.acceptanceRoutes?.[c.id]?.source !== 'explicit_user_runtime_policy' || m.acceptanceRoutes[c.id].authorizationId !== m.policyAuthorization.id || m.acceptanceRoutes[c.id].criterionDigest !== acceptanceIdentity(c))));
 }
 
+// Read-only rollout accounting. Configuration compatibility is not evidence of
+// a dispatched worker, successful repair, or accepted user outcome.
+export function autonomousTaskReadiness(record, now = Date.now()) {
+  const run = record?.run, m = run?.managed;
+  const result = { provider: record.provider, session: record.session, taskId: m?.taskId || null,
+    state: run?.state || 'not_started', configuration: 'not_applicable', continuation: 'not_enrolled' };
+  if (!m || record.provider !== 'codex') return result;
+  const current = m.purpose?.enabled === true && m.purpose.version === 2 && m.purpose.decisionPolicy === 'llm-first-hc102' &&
+    m.purpose.failureBudgetMode === purposeFailureMode(record) && m.controllerContractVersion === AUTONOMOUS_STATE_CONTRACT &&
+    m.resumeChannel === 'codex_app_server' && !policyAdoptionPending(record);
+  result.configuration = current ? 'current' : 'migration_pending';
+  if (record.providerArchived) result.continuation = 'archived';
+  else if (run.state === 'stopped' || run.stopReason?.actor === 'user' || run.state === 'paused' && pauseOrigin(run) === 'user') result.continuation = 'user_stopped';
+  else if (!record.autoContinue || !automaticContinuationAllowed(record)) result.continuation = 'off';
+  else if (['completed', 'reported_done', 'failed', 'budget_exhausted'].includes(run.state)) result.continuation = run.state;
+  else if (!current) result.continuation = 'migration_pending';
+  else if (m.usageBlocked || managedBudgetReason(run, now)) result.continuation = 'budget_boundary';
+  else if (m.pendingApproval || m.nativeWait || m.purpose.nativeBoundary || m.executionUncertain || m.providerWarning) result.continuation = 'authority_or_execution_boundary';
+  else if (['pending', 'transferred', 'pending_received'].includes(m.handoff?.status)) result.continuation = 'handoff_pending';
+  else if (m.resumeLease || m.liveWorkspaceLease || m.outcomeAudit?.lease) result.continuation = 'owned_attempt';
+  else if (run.state === 'verification_pending') {
+    const findings = m.purpose.evidence?.findings?.filter(row => row.status === 'open' && row.owner !== 'human') || [];
+    const pending = effectiveAcceptanceCriteria(m).filter(c => !m.verified?.[c.id]);
+    result.continuation = findings.length ? 'outcome_reinspection_pending' : pending.length && pending.every(c => c.check.type === 'manual') ? 'manual_acceptance' : 'verification_pending';
+  } else result.continuation = run.state === 'recovery_required' && m.autoRecovery ? 'recovery_queued' : run.state;
+  return result;
+}
+
 // Controller-only, idempotent migration. Frozen criteria and grants remain
 // byte-identical, including each criterion's original verifier.
 export function upgradeAutonomousRecord(record, { rules, now, metadata } = {}) {

package/src/session-supervision/purpose-recovery.js

@@ -2,7 +2,7 @@ import { preparePurposeCandidate } from './purpose-candidate.js';
 import { requireProviderLink } from '../provider-links.js';
 import { searchEnabled, purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { createHash } from 'node:crypto';
-import { listRecords, readRecord, updateRecord, automaticContinuationAllowed, queuePurposeDiagnosis, queuePurposeVerification } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { listRecords, readRecord, updateRecord, automaticContinuationAllowed, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { openCodexAppServer, readCodexSession, observeCodexAuthentication } from './codex-app-server.js';
 import { realpath } from 'node:fs/promises';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
@@ -10,6 +10,16 @@ import { purposeEnabled } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
 import { upgradeAutonomousRecord, upgradeEligible, policyAdoptionPending } from './autonomous-upgrade.js';
 import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
 
+function auditReinspectionEligible(run, now) {
+  const m = run?.managed;
+  return run?.state === 'verification_pending' && searchEnabled(m) &&
+    m.purpose.evidence?.findings?.some(row => row.status === 'open' && row.owner !== 'human') &&
+    !m.resumeLease && !m.liveWorkspaceLease && !m.outcomeAudit?.lease &&
+    !m.pendingApproval && !m.nativeWait && !m.purpose.nativeBoundary && !m.executionUncertain &&
+    !m.providerWarning && !m.usageBlocked && !managedBudgetReason(run, now) &&
+    !['pending', 'transferred', 'pending_received'].includes(m.handoff?.status);
+}
+
 export async function observePurposeTurn(record, { openClient = openCodexAppServer } = {}) {
   const client = await openClient();
   try {
@@ -41,6 +51,7 @@ export async function observeUpgradeMetadata(record, { openClient = openCodexApp
 }
 
 export async function reconcilePurposeTasks({ root, signal, prepareCandidate = preparePurposeCandidate, now = Date.now(), observeTurn = observePurposeTurn, observeAuthentication = observeCodexAuthentication, readRecords = () => listRecords(root), observeMetadata = observeUpgradeMetadata }) {
+  const started = Date.now();
   let rules;
   const deferred = [];
 
@@ -234,6 +245,24 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
       obstacle ||= { type: run.blocker, detail: run.managed.understandingQuestion?.text || run.managed.userQuestion ||
         run.managed.dependencyWait?.condition || run.managed.pendingApproval?.summary || run.reason };
     } else if (run.state === 'verification_pending') {
+      // A later independent audit can invalidate an earlier "human only"
+      // disposition. Reinspect its durable findings through the canonical
+      // verifier before assigning repairs; a report is neither a pass nor an
+      // authorization to replay an effect. This also recovers the handoff if
+      // the host exited after persisting findings but before scheduling work.
+      if (auditReinspectionEligible(run, now)) {
+        await persist(current => {
+          const inspectionNow = now + Math.max(0, Date.now() - started);
+          // Auditing can change findings, authority and usage without advancing
+          // the checkpoint CAS. Recheck the full predicate under the state lock.
+          if (current?.run?.id !== run.id || current.run.revision !== run.revision || current.run.state !== run.state || current.run.updatedAt !== run.updatedAt ||
+              !auditReinspectionEligible(current.run, inspectionNow)) return current;
+          queuePurposeVerification(current.run, 'Independent audit left unresolved outcome findings. Reinspect original requirements and current primary evidence; repair genuine gaps or refute incorrect findings with bound counterevidence. Preserve explicit human acceptance.', inspectionNow);
+          current.run.managed.nextAttemptAt = inspectionNow;
+          return current;
+        });
+        continue;
+      }
       if (searchEnabled(run.managed) && (run.managed.purpose.search?.review?.passed || run.managed.purpose.search?.review?.needsHuman) && effectiveAcceptanceCriteria(run.managed).filter(c => !run.managed.verified[c.id]).every(c => c.check.type === 'manual')) continue;
       obstacle = { type: 'verification', detail: run.managed.acceptanceCriteria.filter(c => !run.managed.verified[c.id]).map(c => c.id).join(',') };
     } else if (run.state === 'recovery_required' && ['provider_error', 'process_exit', 'shutdown_cancelled', 'interrupted_owner'].includes(run.recoveryCause) &&