@awak-app/simy-cli 0.1.2 → 0.1.4

package/src/console/app.js

@@ -19,7 +19,7 @@ const TERMINAL_STATES = new Set([
 ]);
 const NEW_TASK = "__new_task__";
 
-export function CodingLoopConsole({ agent, onQuit = () => {} }) {
+export function AgenticLoopConsole({ agent, onQuit = () => {} }) {
   const { exit } = useApp();
   const { stdout } = useStdout();
   const [terminal, setTerminal] = useState(() => terminalSize(stdout));
@@ -138,7 +138,7 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
     }
     if (!selectedRun) {
       if (command.type !== "guidance") {
-        setNotice("That command requires a selected coding run.");
+        setNotice("That command requires a selected Agentic Loop run.");
         return;
       }
       setBusy(true);
@@ -175,12 +175,12 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
             setNotice("Guidance queued for the next executor handoff.");
           } else {
             await agent.controls.continue(selectedRun, command.message);
-            setNotice("Human guidance accepted. The coding loop is continuing.");
+            setNotice("Human guidance accepted. The agentic loop is continuing.");
           }
           break;
         case "decision":
           await agent.controls.applyDecision(selectedRun, command);
-          setNotice("Human decision recorded. The coding loop is continuing.");
+          setNotice("Human decision recorded. The agentic loop is continuing.");
           break;
         case "recheck":
           await agent.controls.recheck(selectedRun);
@@ -259,7 +259,7 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
         await agent.controls.selectRepository(selectedRun, match);
         setDetailOpen(true);
         setDetailScrollFromEnd(0);
-        setNotice(`Authorized ${match.repository}. The same coding run is continuing.`);
+        setNotice(`Authorized ${match.repository}. The same Agentic Loop run is continuing.`);
       } else if (selectedRun) {
         setNotice(
           `${selectedRun.request.repository} was not found under ${result.root}. Run /scan <path> for another authorized root.`,
@@ -290,7 +290,7 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
         setRepositoryPicker(null);
         setDetailOpen(true);
         setDetailScrollFromEnd(0);
-        setNotice(`Authorized ${selected.repository}. The same coding run is continuing.`);
+        setNotice(`Authorized ${selected.repository}. The same Agentic Loop run is continuing.`);
       } else {
         const verified = await agent.controls.selectRepository(null, selected);
         setDraft((current) => ({
@@ -461,7 +461,7 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
       if (confirmStop) void execute("/stop");
       else {
         setConfirmStop(true);
-        setNotice("Press x again to stop the selected coding run.");
+        setNotice("Press x again to stop the selected Agentic Loop run.");
       }
       return;
     }
@@ -534,6 +534,8 @@ export function CodingLoopConsole({ agent, onQuit = () => {} }) {
   });
 }
 
+export const CodingLoopConsole = AgenticLoopConsole;
+
 function Header({ agent, runCount }) {
   return jsxs(Box, {
     borderStyle: "single",

package/src/console/index.js

@@ -1,11 +1,11 @@
 import { jsx } from "react/jsx-runtime";
 import { render } from "ink";
 
-import { CodingLoopConsole } from "./app.js";
+import { AgenticLoopConsole } from "./app.js";
 
-export async function runCodingLoopConsole(agent, options = {}) {
+export async function runAgenticLoopConsole(agent, options = {}) {
   const instance = render(
-    jsx(CodingLoopConsole, {
+    jsx(AgenticLoopConsole, {
       agent,
       onQuit: options.onQuit,
     }),
@@ -21,5 +21,6 @@ export async function runCodingLoopConsole(agent, options = {}) {
   await instance.waitUntilExit();
 }
 
-export { CodingLoopConsole } from "./app.js";
+export const runCodingLoopConsole = runAgenticLoopConsole;
+export { AgenticLoopConsole, CodingLoopConsole } from "./app.js";
 export { consoleHelpLines, parseConsoleCommand } from "./commands.js";

package/src/desktop-executor.js

@@ -0,0 +1,137 @@
+import { spawn } from "node:child_process";
+
+import {
+  BACKEND_VERSION_POLICIES,
+  inspectBackendExecutable,
+} from "./backend-executable.js";
+
+export const DESKTOP_EXECUTION_TARGET = "desktop";
+export const DESKTOP_EXECUTION_LABEL = "Your Desktop";
+
+export function normalizeDesktopExecutionTarget(value) {
+  const target = String(value ?? "").trim().toLowerCase();
+  if (!target || target === DESKTOP_EXECUTION_TARGET) return DESKTOP_EXECUTION_TARGET;
+  const error = new Error(
+    `SIMY CLI runs only on ${DESKTOP_EXECUTION_LABEL}; execution_target must be desktop.`,
+  );
+  error.code = "unsupported_execution_target";
+  error.executionTarget = target;
+  throw error;
+}
+
+export async function inspectDesktopExecutor(backend, options = {}) {
+  const provider = normalizeBackend(backend);
+  const inspection = await inspectBackendExecutable(provider, options);
+  return {
+    execution_target: DESKTOP_EXECUTION_TARGET,
+    execution_label: DESKTOP_EXECUTION_LABEL,
+    provider_label: BACKEND_VERSION_POLICIES[provider].label,
+    ...inspection,
+  };
+}
+
+export function desktopExecutorCapability(inspection) {
+  return {
+    execution_target: DESKTOP_EXECUTION_TARGET,
+    execution_label: DESKTOP_EXECUTION_LABEL,
+    backend: inspection.backend,
+    provider_label: inspection.provider_label,
+    status: inspection.status,
+    available: inspection.available,
+    compatible: inspection.compatible,
+    installed_version: inspection.installed_version,
+    minimum_version: inspection.minimum_version,
+    update_command: inspection.update_command,
+  };
+}
+
+export async function resolveDesktopExecutorCommand({
+  backend,
+  instruction,
+  repositoryPath,
+  environment = process.env,
+  spawnImpl = spawn,
+  inspectionOptions = {},
+} = {}) {
+  const provider = normalizeBackend(backend);
+  const target = normalizeDesktopExecutionTarget(DESKTOP_EXECUTION_TARGET);
+  const override =
+    provider === "claude" ? environment.SIMY_CLAUDE_COMMAND : environment.SIMY_CODEX_COMMAND;
+  if (override) {
+    return {
+      ...shellCommand(override, repositoryPath, instruction, spawnImpl),
+      backend: provider,
+      execution_target: target,
+      verification: "explicit_command_override",
+    };
+  }
+
+  const inspection = await inspectDesktopExecutor(provider, {
+    ...inspectionOptions,
+    spawnImpl: inspectionOptions.spawnImpl ?? spawnImpl,
+  });
+  if (!inspection.compatible || !inspection.executable) {
+    throw desktopExecutorUnavailableError(inspection);
+  }
+  return {
+    bin: inspection.executable,
+    args:
+      provider === "claude"
+        ? claudeBackendArgs(instruction)
+        : ["exec", "--json", instruction],
+    env: {},
+    spawn: spawnImpl,
+    backend: provider,
+    execution_target: target,
+    verification: "compatible_version",
+    installed_version: inspection.installed_version,
+  };
+}
+
+export function claudeBackendArgs(instruction) {
+  return [
+    "-p",
+    instruction,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    // The Agentic Loop is 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 desktop executor.
+    "--dangerously-skip-permissions",
+  ];
+}
+
+function normalizeBackend(backend) {
+  if (backend === "codex" || backend === "claude") return backend;
+  throw new Error("Desktop executor backend must be codex or claude.");
+}
+
+function desktopExecutorUnavailableError(inspection) {
+  const provider = inspection.provider_label;
+  let message;
+  if (inspection.status === "outdated") {
+    message = `${provider} ${inspection.installed_version} is too old for ${DESKTOP_EXECUTION_LABEL}. Update to ${inspection.minimum_version} or newer: ${inspection.update_command}`;
+  } else if (inspection.status === "unknown_version") {
+    message = `${provider} is installed on ${DESKTOP_EXECUTION_LABEL}, but its version could not be verified. Update it and try again: ${inspection.update_command}`;
+  } else {
+    message = `${provider} is not installed on ${DESKTOP_EXECUTION_LABEL}. Install or update it before starting this run: ${inspection.update_command}`;
+  }
+  const error = new Error(message);
+  error.code = `desktop_executor_${inspection.status}`;
+  error.inspection = desktopExecutorCapability(inspection);
+  return error;
+}
+
+function shellCommand(command, cwd, instruction, spawnImpl) {
+  return {
+    bin: process.platform === "win32" ? "cmd.exe" : "sh",
+    args: process.platform === "win32" ? ["/d", "/s", "/c", command] : ["-lc", command],
+    cwd,
+    env: {
+      SIMY_AGENTIC_LOOP_REQUIREMENT: instruction,
+      SIMY_CODING_LOOP_REQUIREMENT: instruction,
+    },
+    spawn: spawnImpl,
+  };
+}

package/src/index.js

@@ -18,7 +18,7 @@ if (args.has("--help") || args.has("-h")) {
 
 Options:
   --daemon, --deamon  Run detached in the background
-  --no-tui            Disable the interactive Coding Loop console
+  --no-tui            Disable the interactive Agentic Loop console
   --no-open           Do not open the browser when authorization is required
   --port <port>       Bind a specific localhost port
   --host <url>        Connect to a SIMY Web origin (default: ${DEFAULT_WEB_ORIGIN})
@@ -53,9 +53,9 @@ if (agent.loginUrl && !args.has("--no-open")) {
   await openAuthorizationUrl(agent.loginUrl);
 }
 if (interactive) {
-  const { runCodingLoopConsole } = await import("./console/index.js");
+  const { runAgenticLoopConsole } = await import("./console/index.js");
   try {
-    await runCodingLoopConsole(agent);
+    await runAgenticLoopConsole(agent);
   } finally {
     await closeServer(agent.server);
   }

package/src/local-attachments.js

@@ -7,7 +7,7 @@ export const MAX_ATTACHMENT_COUNT = 5;
 export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 export const MAX_ATTACHMENTS_TOTAL_BYTES = 50 * 1024 * 1024;
 const RUN_RETENTION_MS = 24 * 60 * 60 * 1000;
-const SAFE_RUN_ID = /^coding_loop_[A-Za-z0-9_-]+$/;
+const SAFE_RUN_ID = /^(?:agentic_loop|coding_loop)_[A-Za-z0-9_-]+$/;
 const ALLOWED_EXACT_MIME_TYPES = new Set([
   "application/json",
   "application/octet-stream",
@@ -32,7 +32,7 @@ export function runsRoot(override) {
 }
 
 export async function stageRunAttachments({ runId, attachments, manifest, root }) {
-  if (!SAFE_RUN_ID.test(runId)) throw new Error("invalid coding loop run_id");
+  if (!SAFE_RUN_ID.test(runId)) throw new Error("invalid agentic loop run_id");
   if (!Array.isArray(attachments) || attachments.length === 0) return [];
   if (attachments.length > MAX_ATTACHMENT_COUNT) {
     throw new Error(`at most ${MAX_ATTACHMENT_COUNT} attachments are allowed`);

package/src/orchestrator/audit.js

@@ -1,4 +1,4 @@
-import { stat } from "node:fs/promises";
+import { open, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 
 import {
@@ -7,8 +7,9 @@ import {
   hasAllowedPrefix,
   stringArray,
 } from "./shared.js";
+import { evaluateRetryProblemSolving } from "./problem-solving.js";
 
-export async function auditAttempt(charter, attempt) {
+export async function auditAttempt(charter, attempt, { previousAttempt = null } = {}) {
   const checks = [];
   const addCheck = (id, label, passed, detail, severity = "blocker", repairability = "auto") => {
     checks.push({ id, label, passed, severity, detail, repairability, evidence_refs: [] });
@@ -112,6 +113,12 @@ export async function auditAttempt(charter, attempt) {
       : "No committed local evidence artifacts reported.",
   );
 
+  const retryProblemSolving = evaluateRetryProblemSolving(attempt, previousAttempt);
+  for (const check of retryProblemSolving.checks) {
+    addCheck(check.id, check.label, check.passed, check.detail);
+  }
+  attempt.retry_problem_solving = retryProblemSolving;
+
   const evidenceRequired = charter.expected_evidence.includes("ui_evidence_path");
   const evidenceArtifact = await inspectEvidence(charter, attempt.ui_evidence_path);
   if (evidenceRequired || attempt.ui_evidence_path) {
@@ -126,6 +133,16 @@ export async function auditAttempt(charter, attempt) {
       evidenceArtifact?.summary || "Local evidence path missing.",
     );
   }
+  if (charter.evidence_policy?.browser_required) {
+    addCheck(
+      "browser_visual_evidence_present",
+      "Browser screenshot or video evidence is present",
+      Boolean(evidenceArtifact?.visual_file_count > 0),
+      evidenceArtifact?.visual_file_count > 0
+        ? `${evidenceArtifact.visual_file_count} screenshot or video artifact(s) found.`
+        : "UI and browser-extension work requires a real screenshot or video; a path, text file, or empty directory is not sufficient.",
+    );
+  }
 
   const findings = checks
     .filter((check) => !check.passed)
@@ -301,17 +318,94 @@ async function inspectEvidence(charter, evidencePath) {
   const underRoot = Boolean(
     root && (resolved === root || resolved.startsWith(`${root}${path.sep}`)),
   );
+  const directoryEvidence = fileStat?.isDirectory()
+    ? await scanEvidenceDirectory(resolved)
+    : null;
+  const directKind = fileStat?.isFile() ? evidenceKind(resolved) : "unknown";
+  const visualFileCount = fileStat?.isFile()
+    ? (await isVisualEvidenceFile(resolved))
+      ? 1
+      : 0
+    : directoryEvidence?.visualFileCount ?? 0;
+  const sizeBytes = fileStat?.isDirectory()
+    ? directoryEvidence?.sizeBytes ?? 0
+    : fileStat?.size ?? 0;
   return {
     path: resolved,
-    kind: fileStat?.isDirectory() ? "directory" : evidenceKind(resolved),
+    kind: fileStat?.isDirectory() ? "directory" : directKind,
     exists: Boolean(fileStat),
     under_required_root: underRoot,
-    size_bytes: fileStat?.size ?? 0,
-    file_count: fileStat?.isFile() ? 1 : 0,
+    size_bytes: sizeBytes,
+    file_count: fileStat?.isFile() ? 1 : directoryEvidence?.fileCount ?? 0,
+    visual_file_count: visualFileCount,
     git_tracked: false,
     summary:
-      fileStat && underRoot && fileStat.size > 0
-        ? "Evidence exists under the required local root."
+      fileStat && underRoot && sizeBytes > 0
+        ? `Evidence exists under the required local root; ${visualFileCount} visual artifact(s) found.`
         : "Evidence is missing, empty, or outside the required local root.",
   };
 }
+
+async function scanEvidenceDirectory(directory) {
+  const pending = [directory];
+  let fileCount = 0;
+  let visualFileCount = 0;
+  let sizeBytes = 0;
+  while (pending.length > 0 && fileCount < 500) {
+    const current = pending.shift();
+    if (!current) break;
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const candidate = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        pending.push(candidate);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      fileCount += 1;
+      if (await isVisualEvidenceFile(candidate)) visualFileCount += 1;
+      try {
+        sizeBytes += (await stat(candidate)).size;
+      } catch {
+        // A file disappearing during inspection is simply not counted toward its size.
+      }
+      if (fileCount >= 500) break;
+    }
+  }
+  return { fileCount, visualFileCount, sizeBytes };
+}
+
+async function isVisualEvidenceFile(filePath) {
+  if (!["image", "video"].includes(evidenceKind(filePath))) return false;
+  const header = Buffer.alloc(16);
+  let handle;
+  try {
+    handle = await open(filePath, "r");
+    const { bytesRead } = await handle.read(header, 0, header.length, 0);
+    if (bytesRead === 0) return false;
+  } catch {
+    return false;
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+      // The evidence file may disappear while it is being inspected.
+    }
+  }
+  const ascii = header.toString("ascii");
+  return (
+    header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ||
+    header.subarray(0, 3).equals(Buffer.from([255, 216, 255])) ||
+    ascii.startsWith("GIF87a") ||
+    ascii.startsWith("GIF89a") ||
+    (ascii.startsWith("RIFF") && ascii.slice(8, 12) === "WEBP") ||
+    ascii.slice(4, 8) === "ftyp" ||
+    header.subarray(0, 4).equals(Buffer.from([26, 69, 223, 163]))
+  );
+}

package/src/orchestrator/budget.js

@@ -0,0 +1,112 @@
+import { clampAttempts } from "./shared.js";
+
+export const DEFAULT_TOKEN_BUDGET = 250_000;
+export const DEFAULT_RETRY_BUDGET = 2;
+const MAX_TOKEN_BUDGET = 10_000_000;
+
+export function resolveRunBudgets(request = {}) {
+  const legacyMaxAttempts = clampAttempts(request.max_attempts);
+  const explicitRetryBudget = integer(request.retry_budget);
+  const retryBudget =
+    explicitRetryBudget === null
+      ? legacyMaxAttempts - 1
+      : Math.min(4, Math.max(0, explicitRetryBudget));
+  return {
+    token_budget: normalizeTokenBudget(request.token_budget),
+    retry_budget: retryBudget,
+    max_attempts: retryBudget + 1,
+  };
+}
+
+export function budgetState(snapshot, pendingAttempt = null) {
+  const attempts = [
+    ...(Array.isArray(snapshot?.attempts) ? snapshot.attempts : []),
+    ...(pendingAttempt ? [pendingAttempt] : []),
+  ];
+  const tokenBudget = normalizeTokenBudget(snapshot?.charter?.token_budget);
+  const retryBudget = normalizeRetryBudget(
+    snapshot?.charter?.retry_budget,
+    snapshot?.charter?.max_attempts,
+  );
+  const tokensUsed = attempts.reduce(
+    (sum, attempt) => sum + tokenUsageTotal(attempt?.token_usage),
+    0,
+  );
+  const attemptsUsed = attempts.length;
+  const retriesUsed = Math.max(attemptsUsed - 1, 0);
+  const tokenExhausted = tokensUsed >= tokenBudget;
+  const retryExhausted = attemptsUsed > 0 && retriesUsed >= retryBudget;
+  return {
+    schema_version: 1,
+    token_budget: tokenBudget,
+    tokens_used: tokensUsed,
+    tokens_remaining: Math.max(tokenBudget - tokensUsed, 0),
+    token_exhausted: tokenExhausted,
+    retry_budget: retryBudget,
+    retries_used: retriesUsed,
+    retries_remaining: Math.max(retryBudget - retriesUsed, 0),
+    retry_exhausted: retryExhausted,
+    exhausted: tokenExhausted || retryExhausted,
+    exhausted_reason: tokenExhausted
+      ? "token_budget_exhausted"
+      : retryExhausted
+        ? "retry_budget_exhausted"
+        : null,
+  };
+}
+
+export function refreshBudgetState(snapshot, pendingAttempt = null) {
+  const state = budgetState(snapshot, pendingAttempt);
+  snapshot.budget = state;
+  return state;
+}
+
+export function canStartProvider(snapshot, { attemptNumber, phase }) {
+  const state = refreshBudgetState(snapshot);
+  if (state.token_exhausted) {
+    return { allowed: false, reason: "token_budget_exhausted", budget: state };
+  }
+  if (phase === "executor" && attemptNumber > state.retry_budget + 1) {
+    return { allowed: false, reason: "retry_budget_exhausted", budget: state };
+  }
+  return { allowed: true, reason: null, budget: state };
+}
+
+export function tokenUsageTotal(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+  if (Array.isArray(value.records)) {
+    return value.records.reduce((sum, record) => sum + recordTokenTotal(record), 0);
+  }
+  return recordTokenTotal(value);
+}
+
+function recordTokenTotal(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+  const explicit = nonNegativeNumber(value.total_tokens);
+  if (explicit !== null) return explicit;
+  return (
+    (nonNegativeNumber(value.tokens_in ?? value.input_tokens) ?? 0) +
+    (nonNegativeNumber(value.tokens_out ?? value.output_tokens) ?? 0)
+  );
+}
+
+function normalizeTokenBudget(value) {
+  const parsed = integer(value);
+  if (parsed === null || parsed <= 0) return DEFAULT_TOKEN_BUDGET;
+  return Math.min(MAX_TOKEN_BUDGET, parsed);
+}
+
+function normalizeRetryBudget(value, maxAttempts) {
+  const parsed = integer(value);
+  if (parsed !== null) return Math.min(4, Math.max(0, parsed));
+  return clampAttempts(maxAttempts) - 1;
+}
+
+function integer(value) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function nonNegativeNumber(value) {
+  return Number.isFinite(value) && value >= 0 ? Math.round(value) : null;
+}