@awak-app/simy-cli 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local SIMY coding-loop agent for Codex and Claude Code.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -421,6 +421,10 @@ export async function startAgent({
         const body = await readJson(req);
         if (body.action === "stop") {
           await stopLocalCodingRun(run);
+          if (run.status !== "stopped" || run.controlState !== "stopped") {
+            json(res, 500, { error: "local executor stop was not confirmed" });
+            return;
+          }
         } else if (body.action === "pause") {
           pauseLocalCodingRun(run);
         } else if (body.action === "resume") {
@@ -545,7 +549,7 @@ export async function startAgent({
             repository: selected.repository,
             local_path: selected.local_path,
             root: scan.root,
-            state: "starting",
+            state: "resuming",
           });
           void continuation.catch((error) => reportRepositoryResumeError(error, quiet));
           return;

package/src/orchestrator/loop.js

@@ -109,6 +109,7 @@ export async function runCodingLoop({
     });
     await publish(snapshot, "collecting_evidence", onUpdate);
     attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
 
     appendEvent(snapshot, "auditing", `Verifying local evidence for attempt ${attemptNumber}.`, {
       attempt_number: attemptNumber,
@@ -122,6 +123,7 @@ export async function runCodingLoop({
     });
     await publish(snapshot, "auditing", onUpdate);
     attempt.audit = await auditAttempt(snapshot.charter, attempt);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
     snapshot.attempts.push(attempt);
 
@@ -162,7 +164,9 @@ export async function runCodingLoop({
 
     // Re-collect after the read-only auditor to catch any mutated HEAD or working tree.
     attempt.observed_evidence = await safeEvidence(collectEvidence, attempt);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.audit = await auditAttempt(snapshot.charter, attempt);
+    if (shouldStop()) return stopCodingLoop(snapshot, onUpdate);
     attempt.implementation_gate = attempt.audit.implementation_gate;
 
     const independentFindings = attempt.independent_audit.findings || [];

package/src/provider-stream.js

@@ -2,6 +2,8 @@ import { stripVTControlCharacters } from "node:util";
 
 const MAX_LINE_CHARS = 2_000;
 const STRUCTURED_MARKERS = ["SIMY_RESULT_JSON:", "SIMY_AUDIT_JSON:"];
+const CODEX_MCP_AUTH_WARNING =
+  "[Codex] MCP warning: optional connector authorization expired; coding continues.";
 
 export function createProviderStreamDecoder({ backend, stream = "stdout", onLine, onUsage }) {
   let pending = "";
@@ -63,6 +65,10 @@ export function formatProviderEvent(backend, event) {
   return backend === "claude" ? formatClaudeEvent(event) : formatCodexEvent(event);
 }
 
+export function isNonFatalProviderDiagnostic(line) {
+  return line === CODEX_MCP_AUTH_WARNING;
+}
+
 function formatCodexEvent(event) {
   const prefix = "[Codex]";
   if (event.type === "thread.started") {
@@ -189,6 +195,9 @@ function contentLines(prefix, label, value) {
 
 function formatPlainLine(backend, stream, value) {
   const prefix = backend === "claude" ? "[Claude Code]" : "[Codex]";
+  if (backend === "codex" && isCodexMcpAuthorizationDiagnostic(value)) {
+    return CODEX_MCP_AUTH_WARNING;
+  }
   const diagnostic = String(value).match(
     /^\S+\s+(WARN|ERROR|INFO)\s+([\w.-]+(?:::[\w.-]+)*):\s*(.*)$/,
   );
@@ -199,6 +208,14 @@ function formatPlainLine(backend, stream, value) {
   return stream === "stderr" ? `${prefix} stderr: ${value}` : `${prefix} ${value}`;
 }
 
+function isCodexMcpAuthorizationDiagnostic(value) {
+  const text = String(value || "");
+  return (
+    /(?:rmcp::|codex_mcp::)/.test(text) &&
+    /(?:invalid_grant|AuthorizationRequired|OAuth authorization required)/i.test(text)
+  );
+}
+
 function toolResultText(value) {
   if (typeof value === "string") return value;
   if (!Array.isArray(value)) return "";

package/src/repository-inventory.js

@@ -110,6 +110,7 @@ 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,
         })),
       },
@@ -129,6 +130,8 @@ export function mergeRepositoryInventory(...inventories) {
     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),
     });
   }
@@ -158,6 +161,7 @@ async function inspectGitRepository(directory) {
     return {
       repository,
       branch: String(branch || "").trim() || "dev",
+      default_branch: await detectDefaultBranch(directory),
       local_path: String(root || "").trim(),
     };
   } catch {
@@ -165,6 +169,32 @@ async function inspectGitRepository(directory) {
   }
 }
 
+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);
 }

package/src/runner.js

@@ -19,7 +19,10 @@ import {
   redactExecutionText,
 } from "./orchestrator/execution-io.js";
 import { summarizeCodingLoopEvent } from "./orchestrator/presentation.js";
-import { createProviderStreamDecoder } from "./provider-stream.js";
+import {
+  createProviderStreamDecoder,
+  isNonFatalProviderDiagnostic,
+} from "./provider-stream.js";
 import { resolveBackendExecutable } from "./backend-executable.js";
 import {
   attachmentDescriptorForLedger,
@@ -256,7 +259,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 +310,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 +323,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 +333,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 +344,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 +357,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,13 +373,32 @@ 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") {
@@ -413,7 +446,7 @@ async function runLocalCodingRun(
     run.snapshot.events.push({
       state: "waiting_human",
       message: "Local repository requires configuration.",
-      detail: { code: "local_repository_not_found" },
+      detail: { code: "local_repository_not_authorized" },
       occurred_at: new Date().toISOString(),
     });
     await cleanupLocalAttachments(run);
@@ -546,6 +579,7 @@ async function executeProcessAttempt({
       cwd: repositoryPath,
       env: { ...process.env, ...command.env },
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
     run.child = child;
 
@@ -564,7 +598,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");
@@ -722,11 +760,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,