outsrc 0.2.0

package/dist/settings.d.ts

@@ -0,0 +1,247 @@
+export declare const SETTINGS_HELP: readonly [{
+    readonly key: "limits.max_jobs";
+    readonly values: 'positive whole number or "unlimited"';
+    readonly default: 4;
+    readonly meaning: "Most jobs working at once, across every caller.";
+}, {
+    readonly key: "limits.max_run_minutes";
+    readonly values: 'positive whole number or "unlimited"';
+    readonly default: 120;
+    readonly meaning: "A run is stopped after this long.";
+}, {
+    readonly key: "repos.<alias>";
+    readonly values: '{"path": "/absolute/path"}';
+    readonly default: null;
+    readonly meaning: "Add a repository agents may work in. unset removes it.";
+}, {
+    readonly key: "repos.<alias>.path";
+    readonly values: "absolute path to a git checkout";
+    readonly default: null;
+    readonly meaning: "Where the repository lives.";
+}, {
+    readonly key: "repos.<alias>.setup";
+    readonly values: 'JSON list of commands, e.g. [["npm","ci"]]';
+    readonly default: readonly [];
+    readonly meaning: "Runs once in a new task worktree before the first run. Never runs for reviews.";
+}, {
+    readonly key: "repos.<alias>.auto_commit";
+    readonly values: "true or false";
+    readonly default: false;
+    readonly meaning: "Commit a successful task's changes on the agent branch.";
+}, {
+    readonly key: "repos.<alias>.retention_days";
+    readonly values: "positive number";
+    readonly default: null;
+    readonly meaning: "outsrc prune removes finished worktrees older than this. Unset keeps them.";
+}, {
+    readonly key: "targets.<name>";
+    readonly values: 'JSON object, e.g. {"adapter":"claude","command":"claude"}';
+    readonly default: null;
+    readonly meaning: "Add an agent outsrc can start. unset removes it.";
+}, {
+    readonly key: "targets.<name>.permissions";
+    readonly values: '"auto" or "ask"';
+    readonly default: "auto";
+    readonly meaning: "auto lets tasks edit and run commands without approval. Reviews always run as ask.";
+}, {
+    readonly key: "targets.<name>.effort.default";
+    readonly values: "one of effort.allowed";
+    readonly default: null;
+    readonly meaning: "Effort used when a request names none.";
+}, {
+    readonly key: "targets.<name>.effort.allowed";
+    readonly values: "comma list or JSON list";
+    readonly default: null;
+    readonly meaning: "Efforts a request may choose.";
+}, {
+    readonly key: "targets.<name>.models.default";
+    readonly values: "one of models.allowed";
+    readonly default: null;
+    readonly meaning: "Model used when a request names none. Without models, the CLI picks.";
+}, {
+    readonly key: "targets.<name>.models.allowed";
+    readonly values: "comma list or JSON list";
+    readonly default: null;
+    readonly meaning: "Models a request may choose.";
+}, {
+    readonly key: "targets.<name>.description";
+    readonly values: "text";
+    readonly default: "";
+    readonly meaning: "Shown to callers in list_targets.";
+}, {
+    readonly key: "targets.<name>.cost_note";
+    readonly values: "text";
+    readonly default: "";
+    readonly meaning: "Shown to callers in list_targets.";
+}, {
+    readonly key: "targets.<name>.adapter";
+    readonly values: "claude, codex, grok, codex-plugin, grok-plugin or custom";
+    readonly default: null;
+    readonly meaning: "How outsrc drives the agent.";
+}, {
+    readonly key: "targets.<name>.command";
+    readonly values: "program path";
+    readonly default: null;
+    readonly meaning: "The program outsrc runs, as you.";
+}, {
+    readonly key: "targets.<name>.args";
+    readonly values: "JSON list of strings";
+    readonly default: readonly [];
+    readonly meaning: "Extra arguments for the program.";
+}];
+export declare const RISKS: {
+    readonly "limits.max_jobs": "No cap on jobs working at once. A looping or confused bot can start many agents together: the computer slows down, usage and cost climb quickly, and providers may rate-limit the account.";
+    readonly "limits.max_run_minutes": "No time limit on a run. A stuck agent (waiting for input it cannot get, a test runner in watch mode, a loop) keeps running and spending until someone stops it.";
+    readonly "permissions.auto": "Tasks on this target edit files and run commands without asking. That is how unattended work gets done, and it is also why only the owner should choose the repositories.";
+    readonly command: "outsrc will run this program as you, with your files and accounts.";
+};
+type Key = {
+    kind: "limit";
+    name: "max_jobs" | "max_run_minutes";
+} | {
+    kind: "repo";
+    alias: string;
+    field: string | null;
+} | {
+    kind: "target";
+    name: string;
+    field: string[] | null;
+};
+export declare function parseKey(key: string): Key;
+export type SettingChange = {
+    ok: true;
+    key: string;
+    value: unknown;
+    warning: string | null;
+} | {
+    ok: false;
+    error: string;
+};
+/** Set (or with value undefined, remove) one setting. The file is only written if the whole config stays valid. */
+export declare function changeSetting(configPath: string, key: string, raw: string | undefined): SettingChange;
+/** Every setting with its effective value, plus the keys an owner can change. */
+export declare function listSettings(configPath: string): {
+    config_path: string;
+    limits: {
+        max_jobs: string | number;
+        max_run_minutes: string | number;
+    };
+    repos: {
+        alias: string;
+        path: string;
+        setup: string[][];
+        auto_commit: boolean;
+        retention_days: number | null;
+    }[];
+    targets: {
+        [k: string]: {
+            adapter: string;
+            command: string;
+            args: string[];
+            permissions: import("./types.js").PermissionMode;
+            models: {
+                default: string;
+                allowed: string[];
+            } | null;
+            effort: {
+                default: string;
+                allowed: string[];
+            } | null;
+            description: string;
+            cost_note: string;
+        };
+    };
+    change_with: string;
+    settings: readonly [{
+        readonly key: "limits.max_jobs";
+        readonly values: 'positive whole number or "unlimited"';
+        readonly default: 4;
+        readonly meaning: "Most jobs working at once, across every caller.";
+    }, {
+        readonly key: "limits.max_run_minutes";
+        readonly values: 'positive whole number or "unlimited"';
+        readonly default: 120;
+        readonly meaning: "A run is stopped after this long.";
+    }, {
+        readonly key: "repos.<alias>";
+        readonly values: '{"path": "/absolute/path"}';
+        readonly default: null;
+        readonly meaning: "Add a repository agents may work in. unset removes it.";
+    }, {
+        readonly key: "repos.<alias>.path";
+        readonly values: "absolute path to a git checkout";
+        readonly default: null;
+        readonly meaning: "Where the repository lives.";
+    }, {
+        readonly key: "repos.<alias>.setup";
+        readonly values: 'JSON list of commands, e.g. [["npm","ci"]]';
+        readonly default: readonly [];
+        readonly meaning: "Runs once in a new task worktree before the first run. Never runs for reviews.";
+    }, {
+        readonly key: "repos.<alias>.auto_commit";
+        readonly values: "true or false";
+        readonly default: false;
+        readonly meaning: "Commit a successful task's changes on the agent branch.";
+    }, {
+        readonly key: "repos.<alias>.retention_days";
+        readonly values: "positive number";
+        readonly default: null;
+        readonly meaning: "outsrc prune removes finished worktrees older than this. Unset keeps them.";
+    }, {
+        readonly key: "targets.<name>";
+        readonly values: 'JSON object, e.g. {"adapter":"claude","command":"claude"}';
+        readonly default: null;
+        readonly meaning: "Add an agent outsrc can start. unset removes it.";
+    }, {
+        readonly key: "targets.<name>.permissions";
+        readonly values: '"auto" or "ask"';
+        readonly default: "auto";
+        readonly meaning: "auto lets tasks edit and run commands without approval. Reviews always run as ask.";
+    }, {
+        readonly key: "targets.<name>.effort.default";
+        readonly values: "one of effort.allowed";
+        readonly default: null;
+        readonly meaning: "Effort used when a request names none.";
+    }, {
+        readonly key: "targets.<name>.effort.allowed";
+        readonly values: "comma list or JSON list";
+        readonly default: null;
+        readonly meaning: "Efforts a request may choose.";
+    }, {
+        readonly key: "targets.<name>.models.default";
+        readonly values: "one of models.allowed";
+        readonly default: null;
+        readonly meaning: "Model used when a request names none. Without models, the CLI picks.";
+    }, {
+        readonly key: "targets.<name>.models.allowed";
+        readonly values: "comma list or JSON list";
+        readonly default: null;
+        readonly meaning: "Models a request may choose.";
+    }, {
+        readonly key: "targets.<name>.description";
+        readonly values: "text";
+        readonly default: "";
+        readonly meaning: "Shown to callers in list_targets.";
+    }, {
+        readonly key: "targets.<name>.cost_note";
+        readonly values: "text";
+        readonly default: "";
+        readonly meaning: "Shown to callers in list_targets.";
+    }, {
+        readonly key: "targets.<name>.adapter";
+        readonly values: "claude, codex, grok, codex-plugin, grok-plugin or custom";
+        readonly default: null;
+        readonly meaning: "How outsrc drives the agent.";
+    }, {
+        readonly key: "targets.<name>.command";
+        readonly values: "program path";
+        readonly default: null;
+        readonly meaning: "The program outsrc runs, as you.";
+    }, {
+        readonly key: "targets.<name>.args";
+        readonly values: "JSON list of strings";
+        readonly default: readonly [];
+        readonly meaning: "Extra arguments for the program.";
+    }];
+};
+export {};

package/dist/settings.js

@@ -0,0 +1,214 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+import { parse, stringify } from "smol-toml";
+import { configFromDocument } from "./config.js";
+import { ensureOutsrcHome, writeHomeFile } from "./fs-home.js";
+import { DEFAULT_LIMITS, resolveLimits } from "./limits.js";
+// Every setting an owner can change, with its default and what it means. Keys use the config.toml names.
+export const SETTINGS_HELP = [
+    { key: "limits.max_jobs", values: 'positive whole number or "unlimited"', default: DEFAULT_LIMITS.max_jobs, meaning: "Most jobs working at once, across every caller." },
+    { key: "limits.max_run_minutes", values: 'positive whole number or "unlimited"', default: DEFAULT_LIMITS.max_run_minutes, meaning: "A run is stopped after this long." },
+    { key: "repos.<alias>", values: '{"path": "/absolute/path"}', default: null, meaning: "Add a repository agents may work in. unset removes it." },
+    { key: "repos.<alias>.path", values: "absolute path to a git checkout", default: null, meaning: "Where the repository lives." },
+    { key: "repos.<alias>.setup", values: 'JSON list of commands, e.g. [["npm","ci"]]', default: [], meaning: "Runs once in a new task worktree before the first run. Never runs for reviews." },
+    { key: "repos.<alias>.auto_commit", values: "true or false", default: false, meaning: "Commit a successful task's changes on the agent branch." },
+    { key: "repos.<alias>.retention_days", values: "positive number", default: null, meaning: "outsrc prune removes finished worktrees older than this. Unset keeps them." },
+    { key: "targets.<name>", values: 'JSON object, e.g. {"adapter":"claude","command":"claude"}', default: null, meaning: "Add an agent outsrc can start. unset removes it." },
+    { key: "targets.<name>.permissions", values: '"auto" or "ask"', default: "auto", meaning: "auto lets tasks edit and run commands without approval. Reviews always run as ask." },
+    { key: "targets.<name>.effort.default", values: "one of effort.allowed", default: null, meaning: "Effort used when a request names none." },
+    { key: "targets.<name>.effort.allowed", values: "comma list or JSON list", default: null, meaning: "Efforts a request may choose." },
+    { key: "targets.<name>.models.default", values: "one of models.allowed", default: null, meaning: "Model used when a request names none. Without models, the CLI picks." },
+    { key: "targets.<name>.models.allowed", values: "comma list or JSON list", default: null, meaning: "Models a request may choose." },
+    { key: "targets.<name>.description", values: "text", default: "", meaning: "Shown to callers in list_targets." },
+    { key: "targets.<name>.cost_note", values: "text", default: "", meaning: "Shown to callers in list_targets." },
+    { key: "targets.<name>.adapter", values: "claude, codex, grok, codex-plugin, grok-plugin or custom", default: null, meaning: "How outsrc drives the agent." },
+    { key: "targets.<name>.command", values: "program path", default: null, meaning: "The program outsrc runs, as you." },
+    { key: "targets.<name>.args", values: "JSON list of strings", default: [], meaning: "Extra arguments for the program." },
+];
+export const RISKS = {
+    "limits.max_jobs": "No cap on jobs working at once. A looping or confused bot can start many agents together: the computer slows down, usage and cost climb quickly, and providers may rate-limit the account.",
+    "limits.max_run_minutes": "No time limit on a run. A stuck agent (waiting for input it cannot get, a test runner in watch mode, a loop) keeps running and spending until someone stops it.",
+    "permissions.auto": "Tasks on this target edit files and run commands without asking. That is how unattended work gets done, and it is also why only the owner should choose the repositories.",
+    command: "outsrc will run this program as you, with your files and accounts.",
+};
+const REPO_FIELDS = ["path", "setup", "auto_commit", "retention_days"];
+const TARGET_FIELDS = ["models.default", "models.allowed", "effort.default", "effort.allowed", "models", "effort",
+    "adapter", "command", "args", "permissions", "description", "cost_note"];
+// Aliases may contain dots (a repository named outsrc.ing), so the field is matched from the end.
+export function parseKey(key) {
+    if (key === "limits.max_jobs" || key === "limits.max_run_minutes")
+        return { kind: "limit", name: key.slice("limits.".length) };
+    for (const [prefix, fields, kind] of [["repos.", REPO_FIELDS, "repo"], ["targets.", TARGET_FIELDS, "target"]]) {
+        if (!key.startsWith(prefix) || key.length === prefix.length)
+            continue;
+        const rest = key.slice(prefix.length);
+        const field = fields.find((candidate) => rest.endsWith(`.${candidate}`) && rest.length > candidate.length + 1);
+        const name = field ? rest.slice(0, -(field.length + 1)) : rest;
+        if (kind === "repo")
+            return { kind, alias: name, field: field ?? null };
+        return { kind, name, field: field ? field.split(".") : null };
+    }
+    throw new Error(`unknown setting: ${key}. Run outsrc config to see every setting`);
+}
+function parseValue(key, raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        value = raw;
+    }
+    if (key.kind === "target" && key.field?.at(-1) === "allowed" && typeof value === "string")
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    return value;
+}
+function readDocument(path) {
+    return existsSync(path) ? parse(readFileSync(path, "utf8")) : {};
+}
+function gitTop(path) {
+    if (!isAbsolute(path))
+        throw new Error(`repository path must be absolute: ${path}`);
+    try {
+        return execFileSync("git", ["-C", path, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        throw new Error(`not a git repository: ${path}`);
+    }
+}
+function apply(document, key, value) {
+    if (key.kind === "limit") {
+        const limits = { ...(document.limits ?? {}) };
+        if (value === undefined)
+            delete limits[key.name];
+        else
+            limits[key.name] = value;
+        document.limits = limits;
+        return;
+    }
+    if (key.kind === "repo") {
+        const repos = [...(document.repos ?? [])];
+        const index = repos.findIndex((repo) => repo.alias === key.alias);
+        if (key.field === null) {
+            if (value === undefined) {
+                if (index < 0)
+                    throw new Error(`unknown repository: ${key.alias}`);
+                repos.splice(index, 1);
+            }
+            else {
+                if (typeof value !== "object" || value === null || Array.isArray(value))
+                    throw new Error(`repos.${key.alias} takes a JSON object such as {"path": "/absolute/path"}`);
+                const entry = { ...(index >= 0 ? repos[index] : {}), ...value, alias: key.alias };
+                if (typeof entry.path === "string")
+                    entry.path = gitTop(entry.path);
+                if (index >= 0)
+                    repos[index] = entry;
+                else
+                    repos.push(entry);
+            }
+        }
+        else {
+            if (index < 0 && !(key.field === "path" && value !== undefined))
+                throw new Error(`unknown repository: ${key.alias}`);
+            const entry = { ...(index >= 0 ? repos[index] : { alias: key.alias }) };
+            if (value === undefined)
+                delete entry[key.field];
+            else
+                entry[key.field] = value;
+            if (key.field === "path" && typeof entry.path === "string")
+                entry.path = gitTop(entry.path);
+            if (index >= 0)
+                repos[index] = entry;
+            else
+                repos.push(entry);
+        }
+        document.repos = repos;
+        return;
+    }
+    const targets = { ...(document.targets ?? {}) };
+    if (key.field === null) {
+        if (value === undefined) {
+            if (!(key.name in targets))
+                throw new Error(`unknown target: ${key.name}`);
+            delete targets[key.name];
+        }
+        else {
+            if (typeof value !== "object" || value === null || Array.isArray(value))
+                throw new Error(`targets.${key.name} takes a JSON object`);
+            targets[key.name] = { ...(targets[key.name] ?? {}), ...value };
+        }
+    }
+    else {
+        if (!(key.name in targets))
+            throw new Error(`unknown target: ${key.name}. Add it first with outsrc config set targets.${key.name} '{"adapter": ..., "command": ...}'`);
+        const target = structuredClone(targets[key.name] ?? {});
+        const [head = "", sub] = key.field;
+        if (sub === undefined) {
+            if (value === undefined)
+                delete target[head];
+            else
+                target[head] = value;
+        }
+        else {
+            const nested = { ...(target[head] ?? {}) };
+            if (value === undefined)
+                delete nested[sub];
+            else
+                nested[sub] = value;
+            if (Object.keys(nested).length)
+                target[head] = nested;
+            else
+                delete target[head];
+        }
+        targets[key.name] = target;
+    }
+    document.targets = targets;
+}
+function risk(key, value) {
+    if ((key === "limits.max_jobs" || key === "limits.max_run_minutes") && value === "unlimited")
+        return RISKS[key];
+    if (key.endsWith(".permissions") && value === "auto")
+        return RISKS["permissions.auto"];
+    if (key.endsWith(".command"))
+        return RISKS.command;
+    return null;
+}
+/** Set (or with value undefined, remove) one setting. The file is only written if the whole config stays valid. */
+export function changeSetting(configPath, key, raw) {
+    try {
+        const parsed = parseKey(key);
+        const value = raw === undefined ? undefined : parseValue(parsed, raw);
+        if (value === "off" && parsed.kind === "repo" && parsed.field === "retention_days")
+            return changeSetting(configPath, key, undefined);
+        const document = readDocument(configPath);
+        apply(document, parsed, value);
+        configFromDocument(document, configPath);
+        ensureOutsrcHome(dirname(configPath));
+        if (existsSync(configPath))
+            copyFileSync(configPath, `${configPath}.bak`);
+        writeHomeFile(configPath, stringify(document));
+        return { ok: true, key, value: value ?? null, warning: risk(key, value) };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: message.startsWith("[") ? `invalid value for ${key}: ${message}` : message };
+    }
+}
+/** Every setting with its effective value, plus the keys an owner can change. */
+export function listSettings(configPath) {
+    const config = configFromDocument(readDocument(configPath), configPath);
+    const limits = resolveLimits(config.limits);
+    return {
+        config_path: configPath,
+        limits: { max_jobs: limits.maxJobs ?? "unlimited", max_run_minutes: limits.maxRunMinutes ?? "unlimited" },
+        repos: config.repos.map((repo) => ({
+            alias: repo.alias, path: repo.path, setup: repo.setup ?? [], auto_commit: repo.autoCommit ?? false, retention_days: repo.retentionDays ?? null,
+        })),
+        targets: Object.fromEntries(Object.entries(config.targets).map(([name, target]) => [name, {
+                adapter: target.adapter ?? name, command: target.command, args: target.args, permissions: target.permissions ?? "auto",
+                models: target.models ?? null, effort: target.effort ?? null, description: target.description ?? "", cost_note: target.costNote ?? "",
+            }])),
+        change_with: "outsrc config set <key> <value>; outsrc config unset <key> restores the default",
+        settings: SETTINGS_HELP,
+    };
+}

package/dist/state.d.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+export declare const ThreadSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./types.js").ThreadId, string>>;
+    caller: z.ZodDefault<z.ZodString>;
+    repo: z.ZodPipe<z.ZodString, z.ZodTransform<import("./types.js").Alias, string>>;
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./types.js").TargetName, string>>;
+    model: z.ZodNullable<z.ZodString>;
+    effort: z.ZodNullable<z.ZodString>;
+    taskKind: z.ZodEnum<{
+        adversarial_review: "adversarial_review";
+        review: "review";
+        task: "task";
+    }>;
+    base: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    worktree: z.ZodString;
+    branch: z.ZodString;
+    baseCommit: z.ZodString;
+    createdAt: z.ZodString;
+    latestRunId: z.ZodString;
+}, z.core.$strip>;
+export declare const RunSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./types.js").RunId, string>>;
+    threadId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./types.js").ThreadId, string>>;
+    requestId: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+    createdAt: z.ZodString;
+    sessionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ResultSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        needs_input: "needs_input";
+    }>;
+    message: z.ZodString;
+    sessionId: z.ZodNullable<z.ZodString>;
+    findings: z.ZodArray<z.ZodObject<{
+        priority: z.ZodEnum<{
+            P0: "P0";
+            P1: "P1";
+            P2: "P2";
+            P3: "P3";
+        }>;
+        title: z.ZodString;
+        body: z.ZodString;
+        path: z.ZodNullable<z.ZodString>;
+        line: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    finishedAt: z.ZodString;
+    diffstat: z.ZodString;
+    commit: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProcessSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    pgid: z.ZodNumber;
+    startedAt: z.ZodString;
+}, z.core.$strip>;
+export declare function writeJson(file: string, value: unknown): void;
+export declare function readJson(file: string): unknown;
+export declare function runDirectory(threadDirectory: string, runId: string): string;
+export declare function readResult(directory: string): {
+    kind: "cancelled" | "completed" | "failed" | "needs_input";
+    message: string;
+    sessionId: string | null;
+    findings: {
+        priority: "P0" | "P1" | "P2" | "P3";
+        title: string;
+        body: string;
+        path: string | null;
+        line: number | null;
+    }[];
+    exitCode: number | null;
+    finishedAt: string;
+    diffstat: string;
+    commit: string | null;
+} | null;

package/dist/state.js

@@ -0,0 +1,61 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, renameSync } from "node:fs";
+import { writeHomeFile } from "./fs-home.js";
+import { join } from "node:path";
+import { z } from "zod";
+import { FindingSchema } from "./adapters.js";
+import { parseAlias, parseRunId, parseTargetName, parseThreadId, STORAGE_ID } from "./types.js";
+export const ThreadSchema = z.object({
+    version: z.literal(2),
+    id: z.string().transform(parseThreadId),
+    caller: z.string().default("local"),
+    repo: z.string().transform(parseAlias),
+    target: z.string().transform(parseTargetName),
+    model: z.string().nullable(),
+    effort: z.string().nullable(),
+    taskKind: z.enum(["task", "review", "adversarial_review"]),
+    base: z.string().nullable().default(null),
+    worktree: z.string(),
+    branch: z.string(),
+    baseCommit: z.string(),
+    createdAt: z.string(),
+    latestRunId: z.string().refine((value) => value === "" || STORAGE_ID.test(value), "latest run id is not a storage id"),
+});
+export const RunSchema = z.object({
+    id: z.string().transform(parseRunId),
+    threadId: z.string().transform(parseThreadId),
+    requestId: z.string().nullable(),
+    message: z.string(),
+    createdAt: z.string(),
+    sessionId: z.string().nullable(),
+});
+export const ResultSchema = z.object({
+    kind: z.enum(["completed", "needs_input", "failed", "cancelled"]),
+    message: z.string(),
+    sessionId: z.string().nullable(),
+    findings: z.array(FindingSchema),
+    exitCode: z.number().nullable(),
+    finishedAt: z.string(),
+    diffstat: z.string(),
+    commit: z.string().nullable(),
+});
+export const ProcessSchema = z.object({
+    pid: z.number().int().gte(2),
+    pgid: z.number().int().gte(2),
+    startedAt: z.string().min(1),
+}).refine((value) => value.pid === value.pgid, "process group must be the wrapper process");
+export function writeJson(file, value) {
+    const temporary = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+    writeHomeFile(temporary, JSON.stringify(value, null, 2));
+    renameSync(temporary, file);
+}
+export function readJson(file) {
+    return JSON.parse(readFileSync(file, "utf8"));
+}
+export function runDirectory(threadDirectory, runId) {
+    return join(threadDirectory, "runs", runId);
+}
+export function readResult(directory) {
+    const file = join(directory, "result.json");
+    return existsSync(file) ? ResultSchema.parse(readJson(file)) : null;
+}