@awak-app/simy-cli 0.1.3 → 0.1.5

package/src/runner.js

@@ -1,4 +1,4 @@
-import { execFile, spawn } from "node:child_process";
+import { execFile } from "node:child_process";
 import { EventEmitter, once } from "node:events";
 import { access } from "node:fs/promises";
 import path from "node:path";
@@ -19,11 +19,17 @@ import {
   redactExecutionText,
 } from "./orchestrator/execution-io.js";
 import { summarizeCodingLoopEvent } from "./orchestrator/presentation.js";
+import { refreshBudgetState } from "./orchestrator/budget.js";
+import { appendEvent } from "./orchestrator/shared.js";
 import {
   createProviderStreamDecoder,
   isNonFatalProviderDiagnostic,
 } from "./provider-stream.js";
-import { resolveBackendExecutable } from "./backend-executable.js";
+import {
+  claudeBackendArgs,
+  normalizeDesktopExecutionTarget,
+  resolveDesktopExecutorCommand,
+} from "./desktop-executor.js";
 import {
   attachmentDescriptorForLedger,
   cleanupRunAttachments,
@@ -70,9 +76,15 @@ export { LocalRunRegistry };
 
 export function createRun({ runId, request, session, apiOrigin }) {
   const emitter = new EventEmitter();
+  const normalizedRequest = {
+    ...request,
+    execution_target: normalizeDesktopExecutionTarget(request?.execution_target),
+    execution_device_id:
+      String(request?.execution_device_id || session?.device_id || "").trim() || null,
+  };
   return {
     id: runId,
-    request,
+    request: normalizedRequest,
     session,
     apiOrigin,
     status: "queued",
@@ -91,7 +103,7 @@ export function createRun({ runId, request, session, apiOrigin }) {
     ledgerUpdateRunning: false,
     snapshot: createCodingLoopSnapshot({
       runId,
-      request,
+      request: normalizedRequest,
       metadata: {
         local_orchestrator_version: 1,
         local_output_persisted: false,
@@ -102,7 +114,7 @@ export function createRun({ runId, request, session, apiOrigin }) {
 
 export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
   if (!snapshot || typeof snapshot !== "object" || !snapshot.charter) {
-    throw new Error("Cannot restore an invalid coding loop snapshot.");
+    throw new Error("Cannot restore an invalid agentic loop snapshot.");
   }
   const charter = snapshot.charter;
   const run = createRun({
@@ -111,6 +123,9 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
     apiOrigin,
     request: {
       backend: charter.backend === "claude" ? "claude" : "codex",
+      execution_target: normalizeDesktopExecutionTarget(charter.execution_target),
+      execution_device_id:
+        String(snapshot.metadata?.execution_device_id || session?.device_id || "").trim() || null,
       audit_backend:
         charter.audit_backend === "claude" || charter.audit_backend === "codex"
           ? charter.audit_backend
@@ -120,6 +135,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
       local_path: localPath,
       base_branch: String(charter.base_branch || "dev"),
       max_attempts: charter.max_attempts,
+      retry_budget: charter.retry_budget,
+      token_budget: charter.token_budget,
       ui_evidence_root: String(charter.ui_evidence_root || ""),
       acceptance_criteria: Array.isArray(charter.acceptance_criteria)
         ? charter.acceptance_criteria
@@ -132,17 +149,38 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
       require_human_approval: charter.require_human_approval !== false,
       must_not: Array.isArray(charter.must_not) ? charter.must_not : [],
       proposal_id: typeof charter.proposal_id === "string" ? charter.proposal_id : null,
+      charter_context: {
+        source_charter_id: charter.id,
+        audit_backend: charter.audit_backend,
+        acceptance_criteria_source: charter.acceptance_criteria_source,
+        required_checks: charter.required_checks,
+        require_human_approval: charter.require_human_approval,
+        risk: charter.risk,
+        design_review: charter.design_review,
+        evidence_policy: charter.evidence_policy,
+        prompt_policy_report: charter.prompt_policy_report,
+        original_request: charter.thread_state?.original_request,
+        user_goal: charter.thread_state?.user_goal,
+        non_goals: charter.thread_state?.non_goals,
+        expected_finish_line: charter.thread_state?.expected_finish_line,
+        artifacts_required: charter.thread_state?.artifacts_required,
+        assumptions: charter.thread_state?.assumptions,
+      },
       attachments: [],
     },
   });
   const restoredSnapshot = structuredClone(snapshot);
+  restoredSnapshot.charter.retry_budget = run.snapshot.charter.retry_budget;
+  restoredSnapshot.charter.token_budget = run.snapshot.charter.token_budget;
+  restoredSnapshot.charter.max_attempts = run.snapshot.charter.max_attempts;
+  refreshBudgetState(restoredSnapshot);
   const lifecycleState = restoredSnapshot.metadata?.pr_lifecycle_state;
   const persistedState =
     typeof lifecycleState === "string" && RESTORABLE_STATES.has(lifecycleState)
       ? lifecycleState
       : restoredSnapshot.state;
   if (!RESTORABLE_STATES.has(persistedState)) {
-    throw new Error(`Coding loop ${run.id} is not in a restorable state.`);
+    throw new Error(`Agentic loop ${run.id} is not in a restorable state.`);
   }
   const restoredFromState = INTERRUPTED_STATES.has(persistedState) ? persistedState : null;
   const restoredState = restoredFromState ? "waiting_human" : persistedState;
@@ -150,15 +188,15 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null }) {
     restoredSnapshot.events = Array.isArray(restoredSnapshot.events)
       ? restoredSnapshot.events
       : [];
-    restoredSnapshot.events.push({
-      state: "waiting_human",
-      message: "Local execution was interrupted and is ready to continue.",
-      detail: {
+    appendEvent(
+      restoredSnapshot,
+      "waiting_human",
+      "Local execution was interrupted and is ready to continue.",
+      {
         code: "local_execution_interrupted",
         interrupted_state: restoredFromState,
       },
-      occurred_at: new Date().toISOString(),
-    });
+    );
   }
 
   run.snapshot = restoredSnapshot;
@@ -193,14 +231,19 @@ export async function startLocalCodingRun(
 export async function continueLocalCodingRun(run, guidance, dependencies = {}) {
   const message = String(guidance || "").trim();
   if (!message) throw new Error("Human guidance is required.");
-  if (run.operation || run.child) throw new Error("The selected coding run is still active.");
+  if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
   if (!RESUMABLE_STATES.has(run.status)) {
     throw new Error("Human guidance is available only when the selected run is waiting.");
   }
 
   const nextAttempt = run.snapshot.attempts.length + 1;
-  if (nextAttempt > 5) throw new Error("The coding run reached the five-attempt safety limit.");
-  run.snapshot.charter.max_attempts = Math.max(run.snapshot.charter.max_attempts, nextAttempt);
+  const budget = refreshBudgetState(run.snapshot);
+  if (budget.token_exhausted) {
+    throw new Error("The Agentic Loop run used its token budget. Start a new run to continue.");
+  }
+  if (nextAttempt > run.snapshot.charter.max_attempts) {
+    throw new Error("The Agentic Loop run used its retry budget. Start a new run to continue.");
+  }
   run.completedAt = null;
   run.stopRequested = false;
   run.controlState = "running";
@@ -219,7 +262,7 @@ export async function continueLocalCodingRunAfterRepositoryApproval(
   if (!approvedRepository || !approvedPath) {
     throw new Error("An approved local repository and path are required.");
   }
-  if (run.operation || run.child) throw new Error("The selected coding run is still active.");
+  if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
   if (run.status !== "waiting_human") {
     throw new Error("Repository approval is available only while the run is waiting.");
   }
@@ -229,14 +272,9 @@ export async function continueLocalCodingRunAfterRepositoryApproval(
 
   run.request.local_path = approvedPath;
   run.snapshot.final_audit = null;
-  run.snapshot.events.push({
-    state: "queued",
-    message: "Local repository authorization accepted.",
-    detail: {
-      code: "local_repository_authorized",
-      repository: approvedRepository,
-    },
-    occurred_at: new Date().toISOString(),
+  appendEvent(run.snapshot, "queued", "Local repository authorization accepted.", {
+    code: "local_repository_authorized",
+    repository: approvedRepository,
   });
   run.snapshot.state = "queued";
   run.status = "queued";
@@ -402,11 +440,8 @@ export function signalExecutorProcess(
 async function finalizeLocalStop(run) {
   if (run.status === "stopped") return;
   if (run.snapshot.events.at(-1)?.state !== "stopped") {
-    run.snapshot.events.push({
-      state: "stopped",
-      message: "Coding loop stopped by the local human operator.",
-      detail: { source: "local_cli" },
-      occurred_at: new Date().toISOString(),
+    appendEvent(run.snapshot, "stopped", "Agentic loop stopped by the local human operator.", {
+      source: "local_cli",
     });
   }
   await updateRun(run, "stopped");
@@ -443,11 +478,8 @@ async function runLocalCodingRun(
     const message = error instanceof Error ? error.message : "Local repository could not be resolved.";
     run.lastOutput = message;
     run.snapshot.final_audit = preflightAudit(message);
-    run.snapshot.events.push({
-      state: "waiting_human",
-      message: "Local repository requires configuration.",
-      detail: { code: "local_repository_not_authorized" },
-      occurred_at: new Date().toISOString(),
+    appendEvent(run.snapshot, "waiting_human", "Local repository requires configuration.", {
+      code: "local_repository_not_authorized",
     });
     await cleanupLocalAttachments(run);
     await updateRun(run, "waiting_human");
@@ -500,23 +532,15 @@ async function runLocalCodingRun(
   } catch (error) {
     const message = error instanceof Error ? error.message : "Local orchestration failed.";
     emitOutput(run, message);
-    run.snapshot.events.push({
-      state: "failed",
-      message: "Local orchestration failed.",
-      detail: { error: message },
-      occurred_at: new Date().toISOString(),
-    });
+    appendEvent(run.snapshot, "failed", "Local orchestration failed.", { error: message });
     await updateRun(run, "failed");
   } finally {
     const cleanupError = await cleanupLocalAttachments(run);
     if (cleanupError) {
       const message = `Local attachment cleanup failed: ${cleanupError}`;
       emitOutput(run, message);
-      run.snapshot.events.push({
-        state: "failed",
-        message: "Local attachment cleanup failed.",
-        detail: { error: cleanupError },
-        occurred_at: new Date().toISOString(),
+      appendEvent(run.snapshot, "failed", "Local attachment cleanup failed.", {
+        error: cleanupError,
       });
       run.snapshot.state = "failed";
     }
@@ -566,7 +590,11 @@ async function executeProcessAttempt({
   marker = "SIMY_RESULT_JSON:",
   attemptNumber = null,
 }) {
-  const command = await resolveBackendCommand({ backend, instruction, repositoryPath });
+  const command = await resolveDesktopExecutorCommand({
+    backend,
+    instruction,
+    repositoryPath,
+  });
   const startedAt = new Date().toISOString();
   const stdout = [];
   const stderr = [];
@@ -646,58 +674,12 @@ async function executeProcessAttempt({
   });
 }
 
-async function resolveBackendCommand({ backend, instruction, repositoryPath }) {
-  if (backend === "claude") {
-    const override = process.env.SIMY_CLAUDE_COMMAND;
-    if (override) return shellCommand(override, repositoryPath, instruction);
-    const binary = (await resolveBackendExecutable("claude")) || "claude";
-    return {
-      bin: binary,
-      args: claudeBackendArgs(instruction),
-      env: {},
-      spawn,
-    };
-  }
-
-  const override = process.env.SIMY_CODEX_COMMAND;
-  if (override) return shellCommand(override, repositoryPath, instruction);
-  const binary = (await resolveBackendExecutable("codex")) || "codex";
-  return {
-    bin: binary,
-    args: ["exec", "--json", instruction],
-    env: {},
-    spawn,
-  };
-}
-
-export function claudeBackendArgs(instruction) {
-  return [
-    "-p",
-    instruction,
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    // The Coding Loop is already scoped to a verified checkout and explicitly
-    // approved by the user. Print mode cannot display permission prompts, so
-    // edits would otherwise be silently unavailable to the executor.
-    "--dangerously-skip-permissions",
-  ];
-}
-
-function shellCommand(command, cwd, instruction) {
-  return {
-    bin: process.platform === "win32" ? "cmd.exe" : "sh",
-    args: process.platform === "win32" ? ["/d", "/s", "/c", command] : ["-lc", command],
-    cwd,
-    env: { SIMY_CODING_LOOP_REQUIREMENT: instruction },
-    spawn,
-  };
-}
+export { claudeBackendArgs } from "./desktop-executor.js";
 
 export async function resolveRepositoryPath(request) {
   const repository = String(request.repository || "").replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
   const repoName = repository.split("/").filter(Boolean).at(-1);
-  if (!repoName) throw new Error("The coding loop did not specify a valid GitHub repository.");
+  if (!repoName) throw new Error("The agentic loop did not specify a valid GitHub repository.");
 
   // An operator-provided root scopes this CLI process to the intended workspace.
   // Persisted inventory paths can outlive a checkout, so only prefer them when no