harness-dispatch 0.9.0 → 0.10.0

package/dist/jobs/lifecycle.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The lifecycle verbs: stop a run, resolve its workspace, run it again.
+ *
+ * These sit above start/read because a retry starts a new job and a cancel
+ * reads one, so the dependency runs one way — lifecycle imports start, never
+ * the reverse.
+ */
+import type { JobDeps, JobStatus } from "./types.js";
+/** What a cancel request actually did — the caller needs to tell these apart. */
+export interface CancelOutcome {
+    jobId: string;
+    /**
+     * `cancelled`  — it was queued and never started; stopped outright.
+     * `cancelling` — it is running; teardown requested and lands shortly.
+     * `already_finished` — it had already reached a terminal state; nothing done.
+     */
+    outcome: "cancelled" | "cancelling" | "already_finished";
+    status: JobStatus["status"];
+    message: string;
+}
+/**
+ * Ask a job to stop.
+ *
+ * Cancellation cannot be a signal here: jobs run inside POOLED supervisors,
+ * and the only pid recorded against a job belongs to a process that is also
+ * running other jobs, so signalling it would cancel work nobody asked to
+ * cancel. Instead this writes a marker the run itself honours — it drops out
+ * of its event stream, which triggers the dispatcher's teardown (killTree on
+ * the agent CLI and its children) and releases the workspace lock through the
+ * same path a normal finish uses.
+ *
+ * Two consequences worth stating plainly, because a caller who assumes
+ * otherwise will be surprised:
+ *
+ *   1. It is not instantaneous. A running job stops within about a second;
+ *      `cancelling` means requested, not done. Poll job_status to see it land.
+ *   2. Work already done is NOT undone. A cancelled agent may have already
+ *      edited files in the workspace, and those edits stay. Cancelling stops
+ *      further work; it is not a rollback.
+ *
+ * A cancelled run is deliberately not recorded as a failure: the route's
+ * circuit breaker and failure count never see it, because the caller changing
+ * their mind says nothing about whether the route works.
+ */
+export declare function cancelJob(jobId: string, reason?: string): Promise<CancelOutcome>;
+/**
+ * Inspect or resolve the isolated workspace a finished job left behind.
+ *
+ * Looks the job up the same way job_status does, then hands off to
+ * workspace-resolve.ts. Kept here so the caller only ever needs a jobId —
+ * where the workspace lives, and which policy produced it, are details
+ * recorded in the job's own result.
+ */
+export declare function resolveJobWorkspace(jobId: string, action: "diff" | "apply" | "discard", opts?: {
+    force?: boolean;
+}): Promise<unknown>;
+export interface RetryOutcome {
+    jobId: string;
+    retryOf: string;
+    service?: string;
+    reusedFrom: {
+        prompt: boolean;
+        files: number;
+        workingDir: string;
+    };
+    /**
+     * The original's model, when the retry's route does not declare it.
+     *
+     * `retryJob` has always SET this and the MCP tool description has always
+     * documented it, but the interface never listed it — the object is built
+     * with a conditional spread, which TypeScript does not excess-property
+     * check. So a typed caller could not see a field that ships, and the tests
+     * asserting it only compiled because the tests were not typechecked.
+     */
+    droppedModel?: string;
+    message: string;
+}
+/**
+ * Run a finished job's task again.
+ *
+ * The last verb missing from the job lifecycle: you could start work, watch
+ * it, stop it, and resolve its workspace — but if it failed, reproducing it
+ * meant reconstructing the prompt, the file list, the working directory and
+ * the hints by hand, from a job record that already holds all four. The
+ * machinery to execute a job bundle existed (executeJobDir) and simply was
+ * not reachable from outside.
+ *
+ * The prompt is taken from prompt.md, which is the FROZEN prompt — including
+ * any context preamble the original dispatch rendered in. A retry therefore
+ * reproduces what the delegate actually saw, not what the caller typed.
+ *
+ * `service` retargets the attempt, which is the common case rather than an
+ * afterthought: the reason a run failed is often the route, not the task
+ * ("codex hit its usage limit — try claude"). Omit it to reuse the original
+ * route, or to let the router pick again if the original had none.
+ */
+export declare function retryJob(jobId: string, deps: JobDeps, opts?: {
+    service?: string;
+}): Promise<RetryOutcome>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/jobs/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/jobs/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqBH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACrD,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,EAAE,WAAW,GAAG,YAAY,GAAG,kBAAkB,CAAC;IACzD,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAqFtF;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,EACpC,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,OAAO,CAAC,OAAO,CAAC,CAsBlB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACnE;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,EACb,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9B,OAAO,CAAC,YAAY,CAAC,CAoFvB"}

package/dist/jobs/lifecycle.js

@@ -0,0 +1,263 @@
+/**
+ * The lifecycle verbs: stop a run, resolve its workspace, run it again.
+ *
+ * These sit above start/read because a retry starts a new job and a cancel
+ * reads one, so the dependency runs one way — lifecycle imports start, never
+ * the reverse.
+ */
+import { getAsyncJob } from "./read.js";
+import { startAsyncJobTracked } from "./start.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { declaresModel } from "../router.js";
+import { applyWorkspace, discardWorkspace, isResolvable, workspaceDiff, } from "../workspace-resolve.js";
+import { requestCancel, jobsRoot, readJson, timestamp, updateStatus, } from "./store.js";
+/**
+ * Ask a job to stop.
+ *
+ * Cancellation cannot be a signal here: jobs run inside POOLED supervisors,
+ * and the only pid recorded against a job belongs to a process that is also
+ * running other jobs, so signalling it would cancel work nobody asked to
+ * cancel. Instead this writes a marker the run itself honours — it drops out
+ * of its event stream, which triggers the dispatcher's teardown (killTree on
+ * the agent CLI and its children) and releases the workspace lock through the
+ * same path a normal finish uses.
+ *
+ * Two consequences worth stating plainly, because a caller who assumes
+ * otherwise will be surprised:
+ *
+ *   1. It is not instantaneous. A running job stops within about a second;
+ *      `cancelling` means requested, not done. Poll job_status to see it land.
+ *   2. Work already done is NOT undone. A cancelled agent may have already
+ *      edited files in the workspace, and those edits stay. Cancelling stops
+ *      further work; it is not a rollback.
+ *
+ * A cancelled run is deliberately not recorded as a failure: the route's
+ * circuit breaker and failure count never see it, because the caller changing
+ * their mind says nothing about whether the route works.
+ */
+export async function cancelJob(jobId, reason) {
+    const job = await getAsyncJob(jobId); // throws the friendly "No such job" for a stranger
+    const current = job.status.status;
+    // There are TWO kinds of orphaned job and they need opposite answers.
+    //
+    //   WRITTEN — `drainSlotQueue` marks a slot-queued job orphaned on disk when
+    //     the server exits before it ever starts. That job is genuinely
+    //     terminal: its own error text says it is not resumed automatically and
+    //     to use retry_job. Cancelling it is a no-op that would leave a marker
+    //     nothing reads.
+    //   DERIVED — `withOrphanCheck` reports a job orphaned when its heartbeat
+    //     goes stale, while the FILE still says `queued` or `running`. That job
+    //     is not inert: once the dead owner's claim ages out, claimNextJob will
+    //     pick it up and run it. Answering "had already finished; nothing to
+    //     cancel" was wrong about work that could still start, and left the
+    //     caller no way to stop it.
+    //
+    // So the raw status decides, not the derived one. `getAsyncJob` has already
+    // applied the orphan check, which is why this re-reads the file.
+    const rawStatus = await readJson(path.join(jobsRoot(), jobId, "status.json")).catch(() => undefined);
+    const terminalOnDisk = rawStatus?.status === "orphaned";
+    if (current === "completed" ||
+        current === "failed" ||
+        current === "cancelled" ||
+        terminalOnDisk) {
+        return {
+            jobId,
+            outcome: "already_finished",
+            status: current,
+            message: `Job ${jobId} had already finished (${current}); nothing to cancel.`,
+        };
+    }
+    const jobDir = path.join(jobsRoot(), jobId);
+    await requestCancel(jobDir, reason);
+    // A job still waiting for a slot has no runner to notice the marker, so
+    // stop it here. claimNextJob also refuses to claim a marked job, which
+    // closes the window where a supervisor picks it up between these two steps.
+    // `orphaned` joins `queued` here rather than falling through to "the runner
+    // will notice the marker": an orphaned job has no live runner BY
+    // DEFINITION, so nothing would ever act on the marker and the job would sit
+    // at "cancelling" forever. The marker written above still matters — it is
+    // what stops a supervisor reclaiming it — but the status has to be settled
+    // here, by the only process still involved.
+    if (current === "queued" || current === "orphaned") {
+        await updateStatus(jobDir, {
+            ...job.status,
+            status: "cancelled",
+            updatedAt: timestamp(),
+            success: false,
+            error: reason !== undefined ? `Cancelled: ${reason}` : "Cancelled before it started.",
+        });
+        // Deliberately NOT draining the slot queue here. Freeing this job's slot
+        // makes room for a waiting one, but drainSlotQueue can SPAWN supervisor
+        // processes, and a cancel — the operation whose whole point is to stop
+        // work — must not start any. Every dispatch and every runner exit already
+        // drains, which is the same "resumes on the next event" contract the
+        // queue documents elsewhere.
+        return {
+            jobId,
+            outcome: "cancelled",
+            status: "cancelled",
+            message: current === "orphaned"
+                ? `Job ${jobId} was orphaned — the process running it is gone — and is now ` +
+                    `marked cancelled, so no supervisor can reclaim it. Any partial output it ` +
+                    `wrote is still available from job_status.`
+                : `Job ${jobId} was waiting for a slot and has been cancelled; it never started.`,
+        };
+    }
+    return {
+        jobId,
+        outcome: "cancelling",
+        status: current,
+        message: `Cancellation requested for ${jobId}. The run stops within a second or so — poll ` +
+            `job_status to confirm. Any files the agent already changed are NOT reverted.`,
+    };
+}
+/**
+ * Inspect or resolve the isolated workspace a finished job left behind.
+ *
+ * Looks the job up the same way job_status does, then hands off to
+ * workspace-resolve.ts. Kept here so the caller only ever needs a jobId —
+ * where the workspace lives, and which policy produced it, are details
+ * recorded in the job's own result.
+ */
+export async function resolveJobWorkspace(jobId, action, opts = {}) {
+    const job = await getAsyncJob(jobId);
+    const run = job.result?.result?.workspace;
+    if (!isResolvable(run)) {
+        // Read through a separate binding: the type guard narrows `run` to never
+        // on this branch, which would make the diagnostic unable to say WHICH
+        // policy the caller actually got.
+        const raw = job.result?.result?.workspace;
+        const policy = raw?.policy ?? "shared";
+        throw new Error(`Job ${jobId} has no isolated workspace to ${action} (workspace policy: ${policy}). ` +
+            `Only 'copy' and 'git_worktree' dispatches produce one — a 'shared' or ` +
+            `'shared_locked' run edited ${raw?.originalWorkingDir ?? "the working directory"} ` +
+            `directly, so there is nothing separate to inspect, apply or throw away.`);
+    }
+    const jobDir = path.join(jobsRoot(), jobId);
+    if (action === "diff")
+        return workspaceDiff(jobId, jobDir, run);
+    if (action === "apply")
+        return applyWorkspace(jobId, jobDir, run, opts);
+    // force reaches discard too: it now refuses to destroy work the project
+    // does not have, and the caller needs the same override apply offers.
+    return discardWorkspace(jobId, run, opts);
+}
+/**
+ * Run a finished job's task again.
+ *
+ * The last verb missing from the job lifecycle: you could start work, watch
+ * it, stop it, and resolve its workspace — but if it failed, reproducing it
+ * meant reconstructing the prompt, the file list, the working directory and
+ * the hints by hand, from a job record that already holds all four. The
+ * machinery to execute a job bundle existed (executeJobDir) and simply was
+ * not reachable from outside.
+ *
+ * The prompt is taken from prompt.md, which is the FROZEN prompt — including
+ * any context preamble the original dispatch rendered in. A retry therefore
+ * reproduces what the delegate actually saw, not what the caller typed.
+ *
+ * `service` retargets the attempt, which is the common case rather than an
+ * afterthought: the reason a run failed is often the route, not the task
+ * ("codex hit its usage limit — try claude"). Omit it to reuse the original
+ * route, or to let the router pick again if the original had none.
+ */
+export async function retryJob(jobId, deps, opts = {}) {
+    const prior = await getAsyncJob(jobId); // friendly "No such job" for a stranger
+    const state = prior.status.status;
+    if (state === "running" || state === "queued") {
+        throw new Error(`Job ${jobId} is still ${state}. Let it finish, or cancel it first with ` +
+            `cancel_job — retrying a live run would leave two attempts racing on the ` +
+            `same working directory.`);
+    }
+    // A DERIVED orphan produces exactly the outcome the message above forbids,
+    // and this guard could not see it.
+    //
+    // `getAsyncJob` reports orphaned when the heartbeat is stale, but the status
+    // FILE still says `queued`, and `claimNextJob` filters on the raw file — so
+    // a supervisor can still claim the original while the retry runs. The guard
+    // reads the derived status, which is neither `running` nor `queued`, so it
+    // let the retry through. `cancelJob` was given this reasoning when it learnt
+    // to tell the two kinds of orphan apart; retry was not, so the fix stopped
+    // one square short.
+    //
+    // Marking the original cancelled is what closes it: claimNextJob refuses a
+    // marked job, so the retry becomes the only attempt. A job orphaned while
+    // RUNNING has no live runner either, so the marker is equally correct there
+    // and simply has nothing left to interrupt.
+    if (state === "orphaned") {
+        const rawStatus = await readJson(path.join(jobsRoot(), jobId, "status.json")).catch(() => undefined);
+        if (rawStatus?.status === "queued" || rawStatus?.status === "running") {
+            await cancelJob(jobId, `superseded by a retry`);
+        }
+    }
+    const manifest = prior.manifest;
+    const prompt = await readFile(manifest.promptPath, "utf8");
+    if (opts.service !== undefined && !(opts.service in deps.holder.state.config.services)) {
+        throw new Error(`Unknown service: ${opts.service}. Valid route ids: ` +
+            `${Object.keys(deps.holder.state.config.services).join(", ")}.`);
+    }
+    const service = opts.service ?? manifest.service;
+    const { hints, droppedModel } = hintsForRetry(manifest.hints, prior.status.route ?? manifest.service, service, deps.holder.state.config.services);
+    const { status } = await startAsyncJobTracked(deps, {
+        prompt,
+        files: manifest.files.map((f) => f.originalPath),
+        workingDir: manifest.workingDir,
+        retryOf: jobId,
+        ...(hints !== undefined ? { hints } : {}),
+        ...(manifest.workspacePolicy !== undefined
+            ? { workspacePolicy: manifest.workspacePolicy }
+            : {}),
+        ...(service !== undefined ? { service } : {}),
+    });
+    return {
+        jobId: status.jobId,
+        retryOf: jobId,
+        ...(service !== undefined ? { service } : {}),
+        ...(droppedModel !== undefined ? { droppedModel } : {}),
+        reusedFrom: {
+            prompt: true,
+            files: manifest.files.length,
+            workingDir: manifest.workingDir,
+        },
+        message: `Started ${status.jobId} from ${jobId}'s prompt, files and working directory` +
+            `${opts.service !== undefined ? `, retargeted to ${opts.service}` : ""}. ` +
+            `${droppedModel !== undefined
+                ? `Left behind the original's model "${droppedModel}", which ${service} does ` +
+                    `not declare — a model name belongs to the route it was chosen for. Pass ` +
+                    `hints.model on a fresh dispatch if you want a specific model here. `
+                : ""}` +
+            `Check it with job_status; the original job is untouched.`,
+    };
+}
+/**
+ * Carry the original's hints into a retry — except a model that belonged to
+ * the route being left behind.
+ *
+ * Retrying somewhere else is the documented reason this tool exists ("the task
+ * was fine and the route was not"), and reusing the model verbatim defeated
+ * exactly that case: model names are route-scoped, so the retry failed for the
+ * same reason as the original. Observed end to end — a Cursor run that died on
+ * `Cannot use this model` was retried onto Claude and died on
+ * `unrecognized_model`, having never reached the task.
+ *
+ * Narrow on purpose. The model is kept when the retry stays on the original's
+ * route (that is a plain "try again"), and when the new route declares it
+ * anyway. Only a model the destination does not know is dropped, and the
+ * caller is told — a silently changed model is the failure this project keeps
+ * finding, so it is reported in the response rather than inferred from a
+ * different result.
+ */
+function hintsForRetry(hints, priorRoute, service, services) {
+    if (hints === undefined)
+        return { hints };
+    const model = hints.model;
+    if (model === undefined || service === undefined || service === priorRoute)
+        return { hints };
+    const target = services[service];
+    if (target === undefined || declaresModel(target, model))
+        return { hints };
+    const { model: _dropped, ...rest } = hints;
+    return { hints: rest, droppedModel: model };
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/jobs/lifecycle.js.map

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

package/dist/jobs/read.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reading a job back: one with its partial output, or the recent list.
+ *
+ * Separate from start.ts because the supervisor reads jobs while deciding
+ * what to run, and start.ts needs the supervisor — keeping the reads beside
+ * the start verbs closed that loop.
+ */
+import type { JobManifest, JobResultPayload, JobStatus } from "./types.js";
+export declare function getAsyncJob(jobId: string): Promise<{
+    manifest: JobManifest;
+    status: JobStatus;
+    result?: JobResultPayload;
+    /** Tail of live stdout/stderr while the job is still running. */
+    partialOutput?: string;
+}>;
+export declare function listAsyncJobs(): Promise<JobStatus[]>;
+//# sourceMappingURL=read.d.ts.map

package/dist/jobs/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/jobs/read.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG3E,wBAAsB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC,CAsED;AAED,wBAAsB,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAgB1D"}

package/dist/jobs/read.js

@@ -0,0 +1,103 @@
+/**
+ * Reading a job back: one with its partial output, or the recent list.
+ *
+ * Separate from start.ts because the supervisor reads jobs while deciding
+ * what to run, and start.ts needs the supervisor — keeping the reads beside
+ * the start verbs closed that loop.
+ */
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { assertValidJobId, jobsRoot, pollInstructions, readJson, SUGGESTED_POLL_SECONDS, withOrphanCheck, } from "./store.js";
+const MAX_PARTIAL_OUTPUT_CHARS = 4000;
+export async function getAsyncJob(jobId) {
+    assertValidJobId(jobId);
+    const jobDir = path.join(jobsRoot(), jobId);
+    // A well-formed id for a job that is gone is the ORDINARY case, not an
+    // internal error: retention prunes finished jobs, so any caller holding an
+    // id long enough will hit this. It used to surface as a raw Node ENOENT
+    // quoting an absolute path inside the jobs directory, which tells the caller
+    // nothing actionable and leaks the layout.
+    const noSuchJob = () => new Error(`No such job: ${jobId}. It may have been pruned by the retention window, ` +
+        `or it was never started on this machine.`);
+    if (!existsSync(path.join(jobDir, "manifest.json")))
+        throw noSuchJob();
+    let manifest;
+    let status;
+    let result;
+    try {
+        manifest = await readJson(path.join(jobDir, "manifest.json"));
+        status = withOrphanCheck(await readJson(path.join(jobDir, "status.json")));
+        const resultPath = path.join(jobDir, "output", "result.json");
+        result = existsSync(resultPath) ? await readJson(resultPath) : undefined;
+    }
+    catch (err) {
+        // existsSync-then-read is a TOCTOU window: retention pruning can delete
+        // the directory between the two calls, resurfacing the exact raw-ENOENT-
+        // with-an-absolute-path error this function's message exists to replace.
+        if (err?.code === "ENOENT")
+            throw noSuchJob();
+        throw err;
+    }
+    if (result !== undefined) {
+        return { manifest, status, result };
+    }
+    // Terminal: no poll guidance — polling will never resolve an orphaned job.
+    // But it still gets its partial output, which is the whole point of the
+    // record surviving the runner.
+    //
+    // This branch used to `return` here, ABOVE the partial-output read below, so
+    // an orphaned job handed back nothing at all while its progress sat in
+    // output/stdout.partial.log. PRODUCT.md's success criterion is explicit that
+    // a dispatch must never die returning nothing — "at worst it fails and hands
+    // back its latest progress… a wasted attempt with no trail is the defining
+    // failure" — and orphaning is exactly the case that criterion was written
+    // for: the supervisor died, so there is no result.json and the partial log
+    // is all that survived. An acceptance pass measured eight chunks of progress
+    // on disk and an empty response.
+    const terminalOrphan = status.status === "orphaned";
+    const out = {
+        manifest,
+        status: terminalOrphan
+            ? status
+            : {
+                ...status,
+                nextPollSeconds: SUGGESTED_POLL_SECONDS,
+                instructions: pollInstructions(jobId),
+            },
+    };
+    const partialPath = path.join(jobDir, "output", "stdout.partial.log");
+    if (existsSync(partialPath)) {
+        try {
+            const partial = await readFile(partialPath, "utf8");
+            out.partialOutput =
+                partial.length <= MAX_PARTIAL_OUTPUT_CHARS
+                    ? partial
+                    : `… [${partial.length - MAX_PARTIAL_OUTPUT_CHARS} chars omitted] …` +
+                        partial.slice(-MAX_PARTIAL_OUTPUT_CHARS);
+        }
+        catch {
+            // Best-effort; absence of partial output isn't an error.
+        }
+    }
+    return out;
+}
+export async function listAsyncJobs() {
+    const root = jobsRoot();
+    if (!existsSync(root))
+        return [];
+    const entries = await readdir(root, { withFileTypes: true });
+    const statuses = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        try {
+            statuses.push(withOrphanCheck(await readJson(path.join(root, entry.name, "status.json"))));
+        }
+        catch {
+            // Ignore incomplete or manually edited job directories.
+        }
+    }
+    return statuses.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+//# sourceMappingURL=read.js.map

package/dist/jobs/read.js.map

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

package/dist/jobs/run.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Running one job: the work a runner process actually does.
+ *
+ * Split out of jobs.ts, which had grown to hold five concerns at 1,600 lines
+ * — this one, admission and the supervisor pool, the start/read verbs, and
+ * the lifecycle verbs. Nothing here was rewritten; the code moved.
+ */
+import type { JobDeps, JobManifest, StartJobInput } from "./types.js";
+export declare function runJob(deps: JobDeps, jobDir: string, manifest: JobManifest, input: StartJobInput): Promise<void>;
+/**
+ * Fallback dispatch timeout for jobs. Dispatchers hard-code a short default
+ * (10 min for CLI harnesses, 2 min for openai_compatible) meant to catch a
+ * genuinely hung process — waiting on stdin that'll never come, a stalled
+ * network call — not to cap a slow-but-healthy run. That default made sense
+ * as-is for `code`, which blocks an MCP call anyway, but `job` runs in the
+ * background and is polled, so nothing about it requires killing a process
+ * that's still making progress after 10 minutes. Below both an explicit
+ * `hints.timeoutMs` and the route's own configured `timeoutMs` in
+ * precedence, so this only fills the gap when nobody set either.
+ *
+ * Router.stream() treats this specific value as a budget for the WHOLE call
+ * (including router fallback retries), not a per-attempt allowance — without
+ * that, a job that falls back twice (the router's default maxFallbacks: 2)
+ * could burn up to 3x this value before failing conclusively.
+ */
+export declare const JOB_DEFAULT_TIMEOUT_MS: number;
+/**
+ * Rebuild a job's input from its on-disk bundle and execute it. This is the
+ * detached runner's whole job; the manifest deliberately carries everything
+ * a run needs (prompt path, resolved workingDir, hints, service) precisely
+ * so execution can happen in a process that wasn't there when the job was
+ * created.
+ */
+export declare function executeJobDir(deps: JobDeps, jobDir: string): Promise<void>;
+/** dist/job-runner.js next to this module (compiled), or via the package's dist/ when running from src. */
+export declare function resolveRunnerPath(): string | undefined;
+/**
+ * Watch a detached job's directory until it reaches a terminal state
+ * (result.json present, or a failed/orphaned status — the orphan check
+ * doubles as the exit path if the runner dies). Timer is unref'd: an
+ * exiting server abandons the watch, which is exactly the point of
+ * detached execution.
+ */
+export declare function watchUntilTerminal(jobDir: string): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/jobs/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/jobs/run.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmBH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAA+B,aAAa,EAAE,MAAM,YAAY,CAAC;AACnG,wBAAsB,MAAM,CAC1B,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,IAAI,CAAC,CA4Of;AAMD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AAGrD;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAchF;AAED,2GAA2G;AAC3G,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAmBtD;AAID;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCtE"}