@awak-app/simy-cli 0.6.17 → 0.6.19

package/src/orchestrator/loop.js

@@ -28,6 +28,10 @@ async function runCodingLoopOwned({
   shouldStop = () => false,
   consumeHumanGuidance = () => "",
 }) {
+  if (resume && snapshot.attempts.at(-1)?.ci_review_refresh_pending) {
+    return recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm, executeIndependentAudit,
+      shouldStop, onUpdate, retryCiReview: true });
+  }
   if (!resume && snapshot.attempts.length > 0 && !snapshot.metadata?.completed_worker_result) {
     return recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm, onUpdate });
   }
@@ -263,39 +267,7 @@ async function runCodingLoopOwned({
     });
     await publish(snapshot, "independent_auditing", onUpdate);
     if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
-    const auditInstruction = buildIndependentAuditInstruction(snapshot.charter, attempt);
-    const reviewedMatrix = attempt.observed_evidence?.minimum_completion?.matrix_sha256;
-    const reviewedEvidenceIdentity = independentAuditEvidenceIdentity(attempt);
-    const reviewedObjectiveDigest = snapshot.charter.thread_state?.objective_contract?.current_digest;
-    const reviewedObjectiveVersion = snapshot.charter.thread_state?.objective_contract?.version;
-    const auditExecution = await safeExecution(() =>
-      executeIndependentAudit({
-        attemptNumber,
-        backend: snapshot.charter.audit_backend,
-        instruction: auditInstruction,
-        charter: snapshot.charter,
-        attempt,
-      }),
-    );
-    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
-    attempt.independent_audit = buildIndependentAudit(
-      auditExecution,
-      snapshot.charter,
-      attempt,
-    );
-    attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
-    attempt.budget = refreshBudgetState(snapshot);
-    recordBudgetWarnings(snapshot, attempt);
-    if (attempt.budget.token_exhausted) {
-      await stopForBudget({ snapshot, attempt, reason: "token_budget_exhausted", onUpdate });
-      return snapshot;
-    }
-
-    attempt.independent_audit.result_parse = normalizeResultParseDiagnostic(auditExecution.result_parse);
-    attempt.independent_audit.minimum_matrix_sha256 = reviewedMatrix;
-    attempt.independent_audit.evidence_identity_sha256 = reviewedEvidenceIdentity;
-    attempt.independent_audit.objective_digest = reviewedObjectiveDigest;
-    attempt.independent_audit.objective_version = reviewedObjectiveVersion;
+    if (await reviewAttempt({ snapshot, attempt, executeIndependentAudit, shouldStop, onUpdate })) return snapshot;
 
     // Re-collect after the read-only auditor to catch any mutated HEAD or working tree.
     attempt.observed_evidence = await safeEvidence(collectEvidence, attempt, { retries: snapshot.metadata?.completed_worker_result ? 2 : 0, shouldStop });
@@ -369,7 +341,63 @@ async function stopCodingLoop(snapshot, onUpdate) {
   return snapshot;
 }
 
-async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = null, onUpdate }) {
+async function reviewAttempt({ snapshot, attempt, executeIndependentAudit, shouldStop, onUpdate }) {
+  const auditInstruction = buildIndependentAuditInstruction(snapshot.charter, attempt);
+  const reviewedMatrix = attempt.observed_evidence?.minimum_completion?.matrix_sha256;
+  const reviewedEvidenceIdentity = independentAuditEvidenceIdentity(attempt);
+  const reviewedChecks = structuredClone(attempt.observed_evidence?.github?.checks || []);
+  const reviewedObjectiveDigest = snapshot.charter.thread_state?.objective_contract?.current_digest;
+  const reviewedObjectiveVersion = snapshot.charter.thread_state?.objective_contract?.version;
+  const auditExecution = await safeExecution(() =>
+    executeIndependentAudit({
+      attemptNumber: attempt.attempt_number,
+      backend: snapshot.charter.audit_backend,
+      instruction: auditInstruction,
+      charter: snapshot.charter,
+      attempt,
+    }),
+  );
+  if (shouldStop()) { await stopCodingLoop(snapshot, onUpdate); return true; }
+  attempt.independent_audit = buildIndependentAudit(
+    auditExecution,
+    snapshot.charter,
+    attempt,
+  );
+  attempt.token_usage = mergeTokenUsage(attempt.token_usage, auditExecution.tokenUsage);
+  attempt.budget = refreshBudgetState(snapshot);
+  recordBudgetWarnings(snapshot, attempt);
+  if (attempt.budget.token_exhausted) {
+    await stopForBudget({ snapshot, attempt, reason: "token_budget_exhausted", onUpdate });
+    return true;
+  }
+
+  attempt.independent_audit.result_parse = normalizeResultParseDiagnostic(auditExecution.result_parse);
+  attempt.independent_audit.reviewed_checks = reviewedChecks;
+  attempt.independent_audit.minimum_matrix_sha256 = reviewedMatrix;
+  attempt.independent_audit.evidence_identity_sha256 = reviewedEvidenceIdentity;
+  attempt.independent_audit.objective_digest = reviewedObjectiveDigest;
+  attempt.independent_audit.objective_version = reviewedObjectiveVersion;
+  return false;
+}
+
+// Only a CI-only change to the already reviewed candidate may automatically
+// renew its review. Head/base/preparation/acceptance changes need explicit work.
+function ciReviewRefreshIdentity(attempt, previousEvidence) {
+  const reviewed = attempt.independent_audit;
+  const github = attempt.observed_evidence?.github;
+  if (!reviewed?.passed || !reviewed.evidence_identity_sha256 || !github?.available ||
+      !attempt.observed_evidence?.local?.available || !attempt.observed_evidence.local.working_tree_clean ||
+      attempt.observed_evidence.local.errors?.length || github.error || !github.required_checks_present || !github.checks_passing ||
+      !github.checks?.length || github.checks.some(check => check.state !== 'success' && check.state !== 'skipped')) return null;
+  const identity = independentAuditEvidenceIdentity(attempt);
+  if (identity === reviewed.evidence_identity_sha256) return null;
+  const prior = { ...attempt, observed_evidence: { ...attempt.observed_evidence,
+    github: { ...github, checks: reviewed.reviewed_checks || previousEvidence?.github?.checks } } };
+  return independentAuditEvidenceIdentity(prior) === reviewed.evidence_identity_sha256 ? identity : null;
+}
+
+async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = null, executeIndependentAudit, shouldStop = () => false, onUpdate, retryCiReview = false }) {
+  if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
   if (!verifyObjective(snapshot.charter).valid) {
     snapshot.implementation_gate_passed = false;
     snapshot.done_gate_passed = false;
@@ -391,6 +419,7 @@ async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = n
       code: "OBJECTIVE_EVIDENCE_STALE", severity: "blocker", target: "objective_contract",
       explanation: "Make a new attempt and independently review evidence against the current objective.", repairability: "manual",
     }]);
+    if (retryCiReview) attempt.ci_review_refresh_pending = false;
     await publish(snapshot, "waiting_human", onUpdate);
     return snapshot;
   }
@@ -398,16 +427,72 @@ async function recheckPrReadinessOwned({ snapshot, collectEvidence, checkSqm = n
     attempt_number: attempt.attempt_number,
   });
   await publish(snapshot, "checking_pr", onUpdate);
+  const previousEvidence = attempt.observed_evidence;
+  // Recover an old review's CI basis only while the saved full identity still
+  // proves it. Later monitoring observations cannot reconstruct that history.
+  if (!attempt.independent_audit?.reviewed_checks &&
+      attempt.independent_audit?.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt) &&
+      Array.isArray(previousEvidence?.github?.checks)) {
+    attempt.independent_audit.reviewed_checks = structuredClone(previousEvidence.github.checks);
+  }
   attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
+  if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
   attempt.sqm = await safeSqm(checkSqm, attempt, attempt.sqm, "full");
+  if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
+  if (retryCiReview && attempt.observed_evidence?.local?.available && attempt.observed_evidence?.github?.available &&
+      independentAuditEvidenceIdentity(attempt) !== attempt.ci_review_refresh_identity) {
+    attempt.ci_review_refresh_pending = false;
+    snapshot.final_audit = humanGate("The candidate changed while its CI review was interrupted.", [{
+      code: "CI_REVIEW_CANDIDATE_CHANGED", severity: "blocker", target: "independent_audit",
+      explanation: "Reconcile the changed HEAD, base or evidence, then explicitly continue work; the prior review cannot certify this candidate.", repairability: "manual",
+    }]);
+    await publish(snapshot, "waiting_human", onUpdate);
+    return snapshot;
+  }
+  const retryIdentity = retryCiReview && attempt.ci_review_refresh_pending &&
+    independentAuditEvidenceIdentity(attempt) === attempt.ci_review_refresh_identity &&
+    attempt.observed_evidence?.local?.available && attempt.observed_evidence.local.working_tree_clean &&
+    !attempt.observed_evidence.local.errors?.length && attempt.observed_evidence?.github?.available &&
+    !attempt.observed_evidence.github.error && attempt.observed_evidence.github.checks_passing &&
+    attempt.observed_evidence.github.required_checks_present ? attempt.ci_review_refresh_identity : null;
+  const refreshIdentity = retryIdentity || ciReviewRefreshIdentity(attempt, previousEvidence);
+  if (executeIndependentAudit && refreshIdentity && (retryIdentity || attempt.ci_review_refresh_identity !== refreshIdentity)) {
+    const budget = canStartProvider(snapshot, { attemptNumber: attempt.attempt_number, phase: "reviewer" });
+    if (!budget.allowed) { await stopForBudget({ snapshot, attempt, reason: budget.reason, onUpdate }); return snapshot; }
+    // Persist before dispatch so an interrupted/failed review cannot repeat on
+    // every monitor tick. Explicit resume retries only this bound review.
+    attempt.ci_review_refresh_identity = refreshIdentity;
+    attempt.ci_review_refresh_pending = true;
+    appendEvent(snapshot, "independent_auditing", "CI completed; refreshing independent review of the same candidate.", {
+      attempt_number: attempt.attempt_number, evidence_identity: refreshIdentity,
+    });
+    await publish(snapshot, "independent_auditing", onUpdate);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
+    if (await reviewAttempt({ snapshot, attempt, executeIndependentAudit, shouldStop, onUpdate })) return snapshot;
+    if (!attempt.independent_audit.passed &&
+        !attempt.independent_audit.findings.some(finding => finding.code === "INDEPENDENT_AUDIT_UNAVAILABLE")) {
+      // A completed adverse review belongs to the normal repair path. Only
+      // unavailable/interrupted reviews need a reviewer-only retry.
+      attempt.ci_review_refresh_pending = false;
+    }
+    attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
+    attempt.sqm = await safeSqm(checkSqm, attempt, attempt.sqm, "full");
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
+  }
   attempt.audit = await auditAttempt(snapshot.charter, attempt, {
     previousAttempt: snapshot.attempts.at(-2) ?? null,
     sqm: attempt.sqm,
   });
+  if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
   attempt.outcome_progress = assessOutcomeProgress(
     snapshot.charter, attempt, snapshot.attempts.at(-2) ?? null,
     outcomeOptions(snapshot),
   );
+  if (attempt.ci_review_refresh_pending && attempt.audit.passed && attempt.independent_audit?.passed &&
+      attempt.independent_audit.evidence_identity_sha256 === independentAuditEvidenceIdentity(attempt)) {
+    attempt.ci_review_refresh_pending = false;
+  }
   snapshot.implementation_gate_passed = attempt.audit.passed;
   attempt.pr_readiness = evaluatePrReadiness(snapshot.charter, attempt);
   attempt.pr_gate = attempt.pr_readiness;

package/src/runner.js

@@ -51,7 +51,7 @@ import {
   normalizeWorkflowStartIntent,
 } from "./workflow-observation-sender.js";
 import { saveCodingRunSnapshot } from "./coding-run-store.js";
-import { acquireDesktopProcessLock } from "./desktop-process-lock.js";
+import { acquireDesktopProcessLock, PROCESS_CONFLICT_CODE } from "./desktop-process-lock.js";
 import {
   assertRecoveryActor, completedWorkerResult, recoveryActorBinding, refreshRecoveryAudit, refreshRecoveryBudgetAudit,
 } from "./coding-run-recovery.js";
@@ -924,7 +924,24 @@ async function cleanupLocalAttachments(run) {
   }
 }
 
-export async function recheckLocalCodingRun(run, { collectEvidence } = {}) {
+export async function recheckLocalCodingRun(run, options = {}) {
+  if (!run?.snapshot?.attempts?.length) return run?.snapshot || null;
+  if (!["pr_ready_for_review", "merge_ready"].includes(run.status)) return run.snapshot;
+  if (run.operation || run.child || run.stopRequested) return run.snapshot;
+  const operation = (async () => {
+    assertRecoveryActor(run);
+    const lease = run.localStateRoot ? await acquireDesktopProcessLock(
+      path.join(run.localStateRoot, ".controllers", executionTextSha256(run.id)),
+    ) : null;
+    try { return await recheckLocalCodingRunOwned(run, options); }
+    finally { await lease?.release(); }
+  })();
+  run.operation = operation;
+  try { return await operation; }
+  finally { if (run.operation === operation) run.operation = null; }
+}
+
+async function recheckLocalCodingRunOwned(run, { collectEvidence, executeIndependentAudit, authorizeReview } = {}) {
   if (!run?.snapshot?.attempts?.length) return run?.snapshot || null;
   if (!["pr_ready_for_review", "merge_ready"].includes(run.status)) return run.snapshot;
   const repositoryPath = await resolveRepositoryPath(run.request);
@@ -956,6 +973,15 @@ export async function recheckLocalCodingRun(run, { collectEvidence } = {}) {
   await recheckPrReadiness({
     snapshot: run.snapshot,
     collectEvidence: evidenceCollector,
+    executeIndependentAudit: async context => {
+      await authorizeReview?.();
+      assertRecoveryActor(run);
+      if (run.stopRequested) throw new Error("Review cancelled by the local operator.");
+      return executeIndependentAudit ? executeIndependentAudit(context) : executeProcessAttempt({
+        ...context, repositoryPath, run, marker: "SIMY_AUDIT_JSON:",
+      });
+    },
+    shouldStop: () => run.stopRequested,
     checkSqm: sqmChecker,
     onUpdate: async (snapshot) => {
       run.snapshot = snapshot;
@@ -966,6 +992,8 @@ export async function recheckLocalCodingRun(run, { collectEvidence } = {}) {
 }
 
 export async function markCodingRunMonitorFailure(run, error) {
+  // A losing controller never owns the right to persist its stale snapshot.
+  if (run.stopRequested || run.status === "stopped" || error?.code === PROCESS_CONFLICT_CODE) return run.snapshot;
   const message = error instanceof Error ? error.message : String(error);
   run.snapshot.done_gate_passed = false;
   run.snapshot.final_audit = {
@@ -1026,6 +1054,7 @@ export async function executeProcessAttempt({
     model: phase === "reviewer" ? charter?.audit_model : charter?.model,
     reasoningEffort: phase === "reviewer" ? charter?.audit_reasoning_effort : charter?.reasoning_effort,
   });
+  if (run.stopRequested) throw new Error("Execution cancelled by the local operator.");
   const startedAt = new Date().toISOString();
   const stdout = [];
   const stderr = [];

package/src/sqm/claude-plugin.js

@@ -22,6 +22,7 @@ export async function claudePluginFiles() {
     files.set(relative, content.replaceAll("current Codex thread", "current Claude Code conversation"));
   }
   files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
+  files.set("hooks/minimal-sufficient.mjs", await readFile(path.join(SOURCE, "hooks/minimal-sufficient.mjs"), "utf8"));
   files.set("hooks/outcome-progress.mjs", await readFile(path.join(SOURCE, "hooks/outcome-progress.mjs"), "utf8"));
   files.set("hooks/continuation-policy.mjs", await readFile(path.join(SOURCE, "hooks/continuation-policy.mjs"), "utf8"));
   files.set("hooks/action-association.mjs", await readFile(path.join(SOURCE, "hooks/action-association.mjs"), "utf8"));

package/src/windows-bootstrap.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { maintainWindowsUpdate, selectedWindowsRoot } from './windows-update.js';
+import { desktopArguments } from './windows-inbound.js';
 const installation = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 const stateRoot = path.join(process.env.LOCALAPPDATA, 'SIMY CLI', 'updates');
 const argv = process.argv.slice(2);
@@ -22,7 +23,7 @@ if (updating) {
   const desktop = argv[0] === '--desktop';
   if (desktop && !existsSync(path.join(root, 'simy-desktop.exe'))) root = installation;
   const child = spawn(path.join(root, desktop ? 'simy-desktop.exe' : 'runtime/node.exe'),
-    desktop ? ['--selected'] : [path.join(root, 'cli/src/index.js'), ...argv], {
+    desktop ? desktopArguments(argv) : [path.join(root, 'cli/src/index.js'), ...argv], {
     stdio: 'inherit', env: { ...process.env, ...(desktop ? {} : { SIMY_AUTO_UPDATE: '0' }) },
   });
   // Windows console signals are already delivered to both processes.

package/src/windows-inbound.js

@@ -0,0 +1,9 @@
+// Keep the URI handoff separate from update and launch code so its exact
+// command shape is covered by a platform-neutral test. desktop.cs remains the
+// authority that validates the URI before it changes a visible selection.
+export function desktopArguments(argv) {
+  // This internal marker distinguishes the desktop spawned by the update
+  // bootstrap from the bootstrap itself. It carries no inbound URI.
+  if (argv.length === 1) return ['--selected'];
+  return ['--selected', ...argv.slice(1)];
+}