@synap-core/cli 1.13.0 → 1.13.1-next.20261102.ec3d166

package/dist/commands/worker-worktrees.js

@@ -0,0 +1,87 @@
+/**
+ * One tree folder per code run, so two runs at once never share a checkout
+ * (finding f94c0287: both worked in the one clone under `--cwd`).
+ *
+ * The worker's `--cwd` is usually a folder OF repos, not a repo, so the worker
+ * cannot create the worktree itself: it gives the run an empty folder
+ * (`<state>/trees/<short id>`) as its cwd, the prompt tells the run to make its
+ * worktrees there (`git -C <cwd>/<repo> worktree add <folder>/<repo> …`), and
+ * when the run ends the worker sweeps the folder: a worktree with no
+ * uncommitted change and no commit that is not on a remote is removed; any
+ * other is KEPT, and named in the run's result.
+ */
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+export const defaultGit = (cwd, args) => new Promise((resolve) => {
+    execFile("git", args, { cwd, timeout: 60_000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout) => {
+        const code = err ? (typeof err.code === "number" ? err.code : 1) : 0;
+        resolve({ code, stdout: String(stdout ?? "") });
+    });
+});
+export function treeFolderFor(treesRoot, sessionId) {
+    return path.join(treesRoot, sessionId.slice(0, 8));
+}
+/** The run's own folder under the trees root; created owner-only. */
+export function ensureTreeFolder(folder) {
+    fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+}
+/**
+ * Removes the run's clean worktrees. A failed check is a reason to KEEP, never
+ * "clean": an unreadable status must not delete work.
+ */
+export async function sweepTreeFolder(folder, git = defaultGit) {
+    const out = { removed: [], kept: [] };
+    let entries;
+    try {
+        entries = fs.readdirSync(folder, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const dir = path.join(folder, e.name);
+        if (!e.isDirectory())
+            continue;
+        if (!fs.existsSync(path.join(dir, ".git"))) {
+            out.kept.push({ dir, why: "not a git worktree" });
+            continue;
+        }
+        const status = await git(dir, ["status", "--porcelain"]);
+        if (status.code !== 0) {
+            out.kept.push({ dir, why: "git status failed" });
+            continue;
+        }
+        if (status.stdout.trim()) {
+            out.kept.push({ dir, why: "uncommitted changes" });
+            continue;
+        }
+        // Commits reachable from HEAD that no remote-tracking ref has: unpushed work.
+        const unpushed = await git(dir, ["rev-list", "--count", "HEAD", "--not", "--remotes"]);
+        if (unpushed.code !== 0 || Number(unpushed.stdout.trim()) !== 0) {
+            out.kept.push({ dir, why: unpushed.code !== 0 ? "git rev-list failed" : "unpushed commits" });
+            continue;
+        }
+        const common = await git(dir, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+        if (common.code !== 0) {
+            out.kept.push({ dir, why: "git-common-dir failed" });
+            continue;
+        }
+        // Run from the main repo: git refuses to remove the worktree it is run in.
+        const removed = await git(path.dirname(common.stdout.trim()), ["worktree", "remove", dir]);
+        if (removed.code !== 0)
+            out.kept.push({ dir, why: "git worktree remove refused" });
+        else
+            out.removed.push(dir);
+    }
+    if (!out.kept.length) {
+        try {
+            fs.rmdirSync(folder);
+        }
+        catch {
+            /* not empty: something else is in it, leave it */
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=worker-worktrees.js.map

package/dist/commands/worker-worktrees.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-worktrees.js","sourceRoot":"","sources":["../../src/commands/worker-worktrees.ts"],"names":[],"mappings":"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"}

package/dist/commands/worker.d.ts

@@ -41,8 +41,13 @@
  * State (which sessions were launched, their Claude session ids and outcome)
  * lives in ~/.synap/worker/<agent>/state.json; each run's stream-json goes to
  * ~/.synap/worker/<agent>/runs/<sessionId>.jsonl. Neither ever holds a token.
+ * A run's verdict is ALSO recorded on its session (`settle`), and the worker's
+ * orient poll carries its served stamp (`X-Synap-Runner`): the pod's proof
+ * that a process serves this agent.
  */
 import { type McpCallClient } from "../lib/mcp-call.js";
+import { type GithubRunEnv, type InstallationTokenSource } from "./worker-github-app.js";
+import { type GitFn } from "./worker-worktrees.js";
 export interface WorkerOptions {
     agent: string;
     interval?: string;
@@ -56,12 +61,21 @@ export interface WorkerOptions {
     dryRun?: boolean;
     /** The Claude accounts file (default ~/.config/synap-worker/accounts.json, used when it exists). */
     accounts?: string;
+    /** The GitHub App env file ({GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY_FILE}; default ~/.config/synap-agent-app.env when it exists). */
+    githubApp?: string;
     /** Where work-folder runs get their folder, one per session (default ~/synap-work). */
     workRoot?: string;
 }
 export interface HandedItem {
     id: string;
     goal: string | null;
+    /**
+     * A session that went quiet (stale) while handed to this agent, handed back
+     * to be RESUMED: it never launches fresh. Absent from an older pod's items.
+     */
+    resume?: true;
+    /** When it went quiet (ISO), with `resume`. */
+    quietSince?: string;
 }
 /** `limited`: cut off by a usage limit, waiting to be resumed on another account. */
 export type RunStatus = "running" | "done" | "failed" | "limited";
@@ -94,6 +108,40 @@ export interface RunRecord {
     protocol?: WorkerProtocol;
     /** A work-folder run's folder: its cwd, which every resume reuses (Claude finds a conversation by its cwd). */
     workDir?: string;
+    /** A code run's own folder for its worktrees: its cwd, which every resume reuses. */
+    treeDir?: string;
+    /** Worktrees a finished run left because they hold unpushed or uncommitted work. */
+    keptTrees?: string[];
+    /** The latest launch's process identity (`X-Synap-Process`), what its runner row is keyed by. */
+    process?: string;
+    /** The model the run's Claude Code said it runs (its stream's `init`), reported as `X-Synap-Model`. */
+    model?: string;
+    /** The quiet period (its `quietSince`, "" when the pod gave none) this run was last resumed for. */
+    resumedQuietSince?: string;
+    /** The latest launch's end, not yet recorded on the pod (`settle`): retried each tick until it lands. */
+    unsettled?: PendingSettle;
+    /** When the latest end was recorded on the pod. */
+    settledAt?: string;
+}
+/**
+ * A run's end the pod has not heard yet, saved before the first try so that a
+ * crash or an MCP blip between the local save and the pod write loses nothing:
+ * the next tick (of this worker, or of the next one after a restart) retries it.
+ * It names its own launch, so a later resume of the same session never changes
+ * which runner it ends or which Result post it is.
+ */
+export interface PendingSettle {
+    /** The launch's process identity and conversation: what the pod's runner row is keyed by. */
+    process?: string;
+    claudeSessionId?: string;
+    /** The verdict to record; absent: the pod only hears the runner ended. */
+    verdict?: {
+        status: VerdictStatus;
+        sentence: string;
+    };
+    /** The Result post's `idempotencyKey`: a retry returns the post that already landed. */
+    key: string;
+    attempts: number;
 }
 interface WorkerState {
     runs: Record<string, RunRecord>;
@@ -129,7 +177,11 @@ export declare function parseHandedToYou(orientText: string): HandedItem[];
  */
 export declare const LAUNCH_RETRY_BASE_MS: number;
 export declare const MAX_LAUNCH_RETRIES = 4;
-/** Sessions to launch now: never launched, or due a relaunch (see above). */
+/**
+ * Sessions to launch now: never launched, or due a relaunch (see above). A
+ * `resume` item is never one of them: it continues its conversation or waits
+ * (see `tick`), so an empty state file never relaunches every quiet session.
+ */
 export declare function pickNew(items: HandedItem[], state: WorkerState, slots: number, now?: number): HandedItem[];
 /**
  * The pod MCP server every run gets, under this name, carrying the WORKER
@@ -139,11 +191,36 @@ export declare function pickNew(items: HandedItem[], state: WorkerState, slots:
  * then read its own posts as follow-ups (2026-10-20).
  */
 export declare const RUN_MCP_SERVER = "synap-worker";
+/**
+ * The provider every run's model is served by: Anthropic, on the account's
+ * subscription. By construction of the run's environment (`workerEnv`): no
+ * `ANTHROPIC_*` (key, token, base URL) and no provider switch
+ * (`RUN_ENV_BLOCKLIST`) reaches it. Reported as `X-Synap-Model-Provider`.
+ */
+export declare const WORKER_MODEL_PROVIDER = "anthropic";
 export declare function runMcpConfig(podUrl: string, apiKey: string, 
 /** The run's Claude session id: names the conversation to the pod, one id across resumes. */
-claudeSessionId?: string): {
+claudeSessionId?: string, 
+/** The launch's process identity (`runProcessIdentity`): the pod keeps one runner row per process. */
+processIdentity?: string, 
+/** The model the run is known to use (a resume: what its first launch said), when known. */
+model?: string): {
     mcpServers: Record<string, unknown>;
 };
+/**
+ * A launch's process identity, `<host>:<pid>:<startedAtMs>` (the pod's
+ * `X-Synap-Process`). The config is written before `claude` exists, so the pid
+ * is the worker's and the time is the launch's: a resume is a new launch and
+ * reads as a new process, never a twin of the one that ended.
+ */
+export declare function runProcessIdentity(launchedAtMs: number, hostname?: string, pid?: number): string;
+/**
+ * The headers of the worker's calls once a run's process exited: the run's
+ * conversation and process, state `ended`, so the pod ends that runner at once
+ * rather than when its live window runs out. None for a run that never named
+ * its conversation or process.
+ */
+export declare function runEndHeaders(rec: Pick<RunRecord, "claudeSessionId" | "process" | "model">): Record<string, string> | undefined;
 /** Writes the run config owner-only (it holds the key) and returns its path. */
 export declare function writeRunMcpConfig(dir: string, config: {
     mcpServers: Record<string, unknown>;
@@ -162,6 +239,8 @@ export declare function buildWorkerPrompt(p: {
     mcpServer: string;
     /** A design run: the deliverable is a claude.ai Design artifact. */
     design?: boolean;
+    /** A code run's own folder: where its worktrees go, so two runs never share a checkout. */
+    treeDir?: string;
 }): string;
 /** How long a work-folder run waits for an answer to its ask before it ends `blocked`. */
 export declare const ASK_WAIT_MINUTES = 30;
@@ -179,10 +258,24 @@ export declare function buildWorkFolderPrompt(p: {
     mcpServer: string;
 }): string;
 /**
- * The launched environment: the subscription, never a stray API key. With an
- * account picked, its token REPLACES any token the worker inherited.
+ * What the allowlist's `CLAUDE_*` must NOT pass: the variables that switch
+ * Claude Code off the subscription to another provider (Bedrock, Vertex,
+ * Foundry, Bedrock Mantle, Claude Platform on AWS — `CLAUDE_CODE_USE_*`), skip
+ * that provider's own auth for a gateway (`CLAUDE_CODE_SKIP_*_AUTH`), or hand
+ * routing to a host platform (`CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`). Any
+ * future `CLAUDE_CODE_USE_*` provider is blocked too; the one `USE_` flag that
+ * is not a provider (the Windows PowerShell tool) passes. Without this a run
+ * would report `anthropic` while another provider served it.
+ */
+export declare const RUN_ENV_BLOCKLIST: RegExp[];
+export declare const RUN_ENV_ALLOWLIST: RegExp[];
+/**
+ * The launched environment, built from an ALLOWLIST: a secret in the worker's
+ * own environment (its env file holds deploy tokens) never reaches a run's
+ * Bash. The subscription, never a stray API key. With an account picked, its
+ * token REPLACES any token the worker inherited. GitHub: only the App's.
  */
-export declare function workerEnv(base: NodeJS.ProcessEnv, claudeConfigDir?: string, oauthToken?: string): NodeJS.ProcessEnv;
+export declare function workerEnv(base: NodeJS.ProcessEnv, claudeConfigDir?: string, oauthToken?: string, github?: GithubRunEnv): NodeJS.ProcessEnv;
 export interface LimitHit {
     error: string;
     /** When the limit lifts (ms), when Claude Code said. */
@@ -191,6 +284,8 @@ export interface LimitHit {
 /** What one run's events say about how it ended. */
 export interface RunEnd {
     claudeSessionId?: string;
+    /** The model the stream's `init` names, when it is an id the pod keeps. */
+    model?: string;
     /** The `result` text (stream) or the last main assistant text (transcript). */
     text?: string;
     /** Set when the run's LAST main-thread turn was refused by a usage limit. */
@@ -275,6 +370,83 @@ export declare const BG_BLOCKED_MAX_MS: number;
 export declare const BG_SETTLE_MS: number;
 /** The final `WORKER-RESULT:` line of a run's result text, if present. */
 export declare function workerVerdict(resultText: string | undefined): string | undefined;
+export type VerdictStatus = "done" | "blocked" | "failed";
+/**
+ * `done — <sentence>` (a `workerVerdict`) → its status and sentence; anything
+ * else is no verdict. The prompt's own template echoed back
+ * (`done | blocked | failed — …`) names no status: it is no verdict either.
+ */
+export declare function parseVerdict(verdict: string | undefined): {
+    status: VerdictStatus;
+    sentence: string;
+} | undefined;
+/**
+ * The verdict the session hears, given how the process ended: `done` only from
+ * a run that exited cleanly; a run that said `done` and then exited non-zero is
+ * `failed`, with what it said kept. `blocked` and `failed` stand as they are.
+ */
+export declare function verdictForExit(v: {
+    status: VerdictStatus;
+    sentence: string;
+}, exitedOk: boolean, exitCode?: number | null): {
+    status: VerdictStatus;
+    sentence: string;
+};
+/** The one room line a verdict becomes. */
+export declare function verdictRoomLine(v: {
+    status: VerdictStatus;
+    sentence: string;
+}): string;
+/**
+ * What the room hears from a run that FAILED without a verdict (it crashed,
+ * exited non-zero without `WORKER-RESULT:`, sat blocked, vanished, ran out of
+ * usage-limit resumes, or the worker restarted under it): how it ended and the
+ * reason the record keeps, on one line.
+ */
+export declare function deadRunSentence(rec: Pick<RunRecord, "result" | "exitCode">): string;
+/**
+ * At most this many tries to record one run's end on the pod. A retry runs
+ * only after the tick's orient read answered, so a pod outage does not use them up.
+ */
+export declare const MAX_SETTLE_ATTEMPTS = 10;
+/**
+ * The end a run owes the pod, given what it said and how its process ended:
+ * its verdict (`verdictForExit`), or for a run that failed without one a
+ * synthesised `failed` (`deadRunSentence`), so a dead run is never silent.
+ * `undefined` when there is nothing to tell (no verdict, not failed, and no
+ * runner to end).
+ */
+export declare function pendingSettle(rec: RunRecord, verdictLine: string | undefined, exitedOk: boolean): PendingSettle | undefined;
+/**
+ * Outcome kinds a verdict never claims: a pull request is delivered only when
+ * it merges (rule work-units), and the merge sweeper marks it met then; a
+ * branch or a commit is a step toward that PR, not a deliverable of its own.
+ */
+export declare const UNCLAIMABLE_OUTCOME_KINDS: ReadonlySet<string>;
+/** What the session read says a `done` verdict may claim. */
+export type VerdictClaim = {
+    kind: "one";
+    key: string;
+} | {
+    kind: "none";
+} | {
+    kind: "several";
+    keys: string[];
+}
+/** The outcomes list could not be read: nothing is claimed, and that is said. */
+ | {
+    kind: "unreadable";
+    why: string;
+};
+/**
+ * The outcome a `done` verdict claims, from the `synap_get_session` read: the
+ * session's ONE open deliverable the agent owns (not a fact, not the person's,
+ * not met, not withdrawn, never a PR, branch or commit). None, or several, and
+ * nothing is claimed: which of several the run finished is the run's to say
+ * (it claims each as it records it). An outcomes list that could not be read is
+ * `unreadable`, never "none open".
+ */
+export declare function verdictClaim(getSessionText: string): VerdictClaim;
 export interface RoomMessage {
     id?: string;
     content?: string;
@@ -290,6 +462,17 @@ export declare const MAX_RESUMES = 20;
  * run. The worker's own posts carry its agent id and never resume it.
  */
 export declare function followUpsSince(messages: RoomMessage[], since: string, selfAgentId: string): RoomMessage[];
+/**
+ * Whether a session's quiet period began with THIS worker's own run: the pod's
+ * `quietSince` is the session's newest activity, and the run's own room posts
+ * (its claim, its "Look at first:", the worker's `Result:` line) count. Quiet
+ * since then means the run ended and nothing happened after it; resuming it
+ * would only re-run it (up to MAX_RESUMES paid runs). Someone else's message
+ * after the run resumes it through the follow-up path instead.
+ */
+export declare function quietIsOwnRun(item: Pick<HandedItem, "quietSince">, rec: Pick<RunRecord, "launchedAt">): boolean;
+/** The prompt that resumes a run whose session went quiet and was handed back (`resume`). */
+export declare function buildQuietResumePrompt(quietSince: string | undefined): string;
 /** The prompt that resumes a finished run with the room's new messages. */
 export declare function buildFollowUpPrompt(messages: RoomMessage[]): string;
 export interface ExecResult {
@@ -313,6 +496,10 @@ export interface WorkerDeps {
     fetchImpl?: typeof fetch;
     now?: () => number;
     say?: (line: string) => void;
+    /** The App's installation token (tests stub it); default: from the GitHub App file, when there is one. */
+    githubToken?: InstallationTokenSource;
+    /** `git` for the worktree sweep (tests stub it). */
+    git?: GitFn;
 }
 export interface Worker {
     tick(): Promise<{