@awak-app/simy-cli 0.1.2 → 0.1.4

package/src/repository-inventory.js

@@ -110,7 +110,9 @@ export async function writeRepositoryInventory(
         repositories: mergeRepositoryInventory(repositories).map((item) => ({
           repository: item.repository,
           branch: item.branch,
+          default_branch: item.default_branch,
           local_path: item.local_path,
+          ...(item.capabilities?.length ? { capabilities: item.capabilities } : {}),
         })),
       },
       null,
@@ -126,10 +128,14 @@ export function mergeRepositoryInventory(...inventories) {
     const repository = normalizeGitHubRemote(item?.repository);
     const localPath = String(item?.local_path || item?.localPath || "").trim();
     if (!repository || !localPath) continue;
+    const capabilities = uniqueCapabilities(item?.capabilities);
     byPath.set(resolve(localPath), {
       repository,
       branch: String(item?.branch || "").trim() || "dev",
+      default_branch:
+        String(item?.default_branch || item?.defaultBranch || "").trim() || "dev",
       local_path: resolve(localPath),
+      ...(capabilities.length ? { capabilities } : {}),
     });
   }
   return [...byPath.values()].sort((left, right) =>
@@ -155,16 +161,114 @@ async function inspectGitRepository(directory) {
     ]);
     const repository = normalizeGitHubRemote(remote);
     if (!repository) return null;
+    const capabilities = await inspectRepositoryCapabilities(directory);
     return {
       repository,
       branch: String(branch || "").trim() || "dev",
+      default_branch: await detectDefaultBranch(directory),
       local_path: String(root || "").trim(),
+      ...(capabilities.length ? { capabilities } : {}),
     };
   } catch {
     return null;
   }
 }
 
+async function inspectRepositoryCapabilities(directory) {
+  const capabilities = [];
+  const rootEntries = await safeDirectoryNames(directory);
+  const packageJson = await readJsonFile(join(directory, "package.json"));
+  const packageNames = Object.keys({
+    ...(packageJson?.dependencies || {}),
+    ...(packageJson?.devDependencies || {}),
+  });
+  const pythonConfig = await readTextFile(join(directory, "pyproject.toml"));
+  const extensionManifest =
+    (await readJsonFile(join(directory, "extension", "manifest.json"))) ||
+    (await readJsonFile(join(directory, "manifest.json")));
+
+  if (
+    packageNames.some((name) => ["next", "react-dom", "vue", "svelte"].includes(name)) ||
+    [...rootEntries].some((name) => /^next\.config\./.test(name))
+  ) {
+    capabilities.push("web_ui");
+  }
+  if ([2, 3].includes(extensionManifest?.manifest_version)) {
+    capabilities.push("browser_extension");
+  }
+  if (rootEntries.has("pubspec.yaml")) capabilities.push("mobile_ui");
+  if (rootEntries.has("supabase") || rootEntries.has("migrations")) {
+    capabilities.push("database_backend");
+  }
+  if (
+    packageJson?.bin ||
+    packageNames.some((name) => ["commander", "ink", "yargs", "oclif"].includes(name))
+  ) {
+    capabilities.push("cli");
+  }
+  if (/\b(langgraph|langchain|crewai|autogen|openai-agents)\b/i.test(pythonConfig)) {
+    capabilities.push("agent_runtime");
+  }
+  if (
+    /\b(fastapi|django|flask)\b/i.test(pythonConfig) ||
+    packageNames.some((name) => ["express", "fastify", "hono", "koa"].includes(name))
+  ) {
+    capabilities.push("backend_api");
+  }
+  return uniqueCapabilities(capabilities);
+}
+
+async function safeDirectoryNames(directory) {
+  try {
+    return new Set((await readdir(directory, { withFileTypes: true })).map((entry) => entry.name));
+  } catch {
+    return new Set();
+  }
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function readTextFile(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+async function detectDefaultBranch(directory) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+      { cwd: directory },
+    );
+    const branch = String(stdout || "").trim().replace(/^origin\//, "");
+    if (branch) return branch;
+  } catch {
+    // Fall through to local remote refs for repositories without origin/HEAD.
+  }
+
+  for (const branch of ["dev", "main", "master"]) {
+    try {
+      await execFileAsync("git", ["show-ref", "--verify", `refs/remotes/origin/${branch}`], {
+        cwd: directory,
+      });
+      return branch;
+    } catch {
+      // Try the next conventional default branch.
+    }
+  }
+  return "dev";
+}
+
 function shouldSkipDirectory(name) {
   return name.startsWith(".") || SKIPPED_DIRECTORIES.has(name);
 }
@@ -177,6 +281,19 @@ function uniqueStrings(values) {
   return [...new Set((Array.isArray(values) ? values : []).map(String).filter(Boolean))];
 }
 
+function uniqueCapabilities(values) {
+  const allowed = new Set([
+    "web_ui",
+    "browser_extension",
+    "mobile_ui",
+    "database_backend",
+    "backend_api",
+    "agent_runtime",
+    "cli",
+  ]);
+  return [...new Set((Array.isArray(values) ? values : []).filter((value) => allowed.has(value)))].sort();
+}
+
 function emptyInventory() {
   return { version: INVENTORY_VERSION, authorizedRoots: [], repositories: [], scannedAt: null };
 }

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,8 +19,17 @@ import {
   redactExecutionText,
 } from "./orchestrator/execution-io.js";
 import { summarizeCodingLoopEvent } from "./orchestrator/presentation.js";
-import { createProviderStreamDecoder } from "./provider-stream.js";
-import { resolveBackendExecutable } from "./backend-executable.js";
+import { refreshBudgetState } from "./orchestrator/budget.js";
+import { appendEvent } from "./orchestrator/shared.js";
+import {
+  createProviderStreamDecoder,
+  isNonFatalProviderDiagnostic,
+} from "./provider-stream.js";
+import {
+  claudeBackendArgs,
+  normalizeDesktopExecutionTarget,
+  resolveDesktopExecutorCommand,
+} from "./desktop-executor.js";
 import {
   attachmentDescriptorForLedger,
   cleanupRunAttachments,
@@ -67,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",
@@ -88,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,
@@ -99,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({
@@ -108,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
@@ -117,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
@@ -129,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;
@@ -147,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;
@@ -190,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";
@@ -216,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.");
   }
@@ -226,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";
@@ -256,7 +297,9 @@ export function isLocalRepositoryApprovalPending(run) {
   if (run?.status !== "waiting_human" || run.snapshot?.attempts?.length > 0) return false;
   const events = Array.isArray(run.snapshot?.events) ? run.snapshot.events : [];
   const markerIndex = events.findLastIndex(
-    (event) => event?.detail?.code === "local_repository_not_found",
+    (event) =>
+      event?.detail?.code === "local_repository_not_authorized" ||
+      event?.detail?.code === "local_repository_not_found",
   );
   if (markerIndex < 0) return false;
   return events
@@ -305,7 +348,9 @@ export function pauseLocalCodingRun(run) {
   if (process.platform === "win32") {
     throw new Error("Process pause is not supported on Windows; stop the run instead.");
   }
-  if (!run.child.kill("SIGSTOP")) throw new Error("The executor process could not be paused.");
+  if (!signalExecutorProcess(run.child, "SIGSTOP")) {
+    throw new Error("The executor process could not be paused.");
+  }
   run.controlState = "paused";
   emitControl(run, "paused", "Executor paused by the local human operator.");
 }
@@ -316,7 +361,9 @@ export function resumeLocalCodingRun(run) {
   if (process.platform === "win32") {
     throw new Error("Process resume is not supported on Windows.");
   }
-  if (!run.child.kill("SIGCONT")) throw new Error("The executor process could not be resumed.");
+  if (!signalExecutorProcess(run.child, "SIGCONT")) {
+    throw new Error("The executor process could not be resumed.");
+  }
   run.controlState = "running";
   emitControl(run, "resumed", "Executor resumed by the local human operator.");
 }
@@ -324,7 +371,9 @@ export function resumeLocalCodingRun(run) {
 export async function stopLocalCodingRun(run) {
   if (run.status === "stopped") return run.snapshot;
   if (run.stopRequested) {
-    await waitForLocalStop(run);
+    const stopped = await waitForLocalStop(run);
+    if (!stopped) throw new Error("The local executor did not stop within the safety timeout.");
+    await finalizeLocalStop(run);
     return run.snapshot;
   }
   run.stopRequested = true;
@@ -333,6 +382,8 @@ export async function stopLocalCodingRun(run) {
 
   const child = run.child;
   if (!child) {
+    const stopped = await waitForLocalStop(run);
+    if (!stopped) throw new Error("The local executor did not stop within the safety timeout.");
     await finalizeLocalStop(run);
     return run.snapshot;
   }
@@ -344,14 +395,15 @@ export async function stopLocalCodingRun(run) {
   if (outcome === "timeout" && run.child === child) {
     await signalAndWaitForClose(child, "SIGKILL", 750);
   }
-  await waitForLocalStop(run);
+  const stopped = await waitForLocalStop(run);
+  if (!stopped) throw new Error("The local executor did not stop within the safety timeout.");
   await finalizeLocalStop(run);
   return run.snapshot;
 }
 
 async function signalAndWaitForClose(child, signal, timeoutMs) {
   const close = once(child, "close").then(() => "closed");
-  child.kill(signal);
+  signalExecutorProcess(child, signal);
   return Promise.race([
     close,
     new Promise((resolve) => setTimeout(() => resolve("timeout"), timeoutMs)),
@@ -359,21 +411,37 @@ async function signalAndWaitForClose(child, signal, timeoutMs) {
 }
 
 async function waitForLocalStop(run) {
-  if (!run.operation) return;
-  await Promise.race([
-    run.operation.catch(() => null),
-    new Promise((resolve) => setTimeout(resolve, 1_500)),
+  if (!run.operation) return true;
+  return Promise.race([
+    run.operation.then(
+      () => true,
+      () => true,
+    ),
+    new Promise((resolve) => setTimeout(() => resolve(false), 10_000)),
   ]);
 }
 
+export function signalExecutorProcess(
+  child,
+  signal,
+  { killProcess = process.kill, platform = process.platform } = {},
+) {
+  if (platform !== "win32" && Number.isInteger(child?.pid)) {
+    try {
+      killProcess(-child.pid, signal);
+      return true;
+    } catch (error) {
+      if (error?.code !== "ESRCH") return child.kill?.(signal) === true;
+    }
+  }
+  return child?.kill?.(signal) === true;
+}
+
 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");
@@ -410,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_found" },
-      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");
@@ -467,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";
     }
@@ -533,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 = [];
@@ -546,6 +607,7 @@ async function executeProcessAttempt({
       cwd: repositoryPath,
       env: { ...process.env, ...command.env },
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
     run.child = child;
 
@@ -564,7 +626,11 @@ async function executeProcessAttempt({
     const stderrDecoder = createProviderStreamDecoder({
       backend,
       stream: "stderr",
-      onLine: (line) => emitOutput(run, line, { backend }),
+      onLine: (line) =>
+        emitOutput(run, line, {
+          backend,
+          promote: !isNonFatalProviderDiagnostic(line),
+        }),
     });
     const collect = (target, decoder, chunk) => {
       const text = chunk.toString("utf8");
@@ -608,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
@@ -722,11 +742,11 @@ function extractAssistantText(raw) {
   return messages.join("\n");
 }
 
-function emitOutput(run, text, { backend = run.request.backend } = {}) {
+function emitOutput(run, text, { backend = run.request.backend, promote = true } = {}) {
   for (const line of String(text).split(/\r?\n/)) {
     if (!line.trim()) continue;
     const occurredAt = new Date().toISOString();
-    run.lastOutput = line;
+    if (promote) run.lastOutput = line;
     run.logs.push({
       text: line,
       backend,