looply-cli 0.0.0-stage → 0.2.0

package/dist/run-ending-locator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-ending-locator.d.ts","sourceRoot":"","sources":["../src/run-ending-locator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAE,WAAW,EAAkB,KAAK,OAAO,EAAE,KAAK,WAAW,EAAa,MAAM,aAAa,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,aAAa,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,WAAW,CAAC;CAC9B;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3F;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAkB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAe7I;AAED,oFAAoF;AACpF,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,GAAG,UAAU,CAAC;AAEtF,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE;AAClE,oFAAoF;GAClF;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,GAC3E,eAAe,CAajB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAiEvG"}

package/dist/run-ending-locator.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProjectExecutionRoot = isProjectExecutionRoot;
+exports.locateRunCheckout = locateRunCheckout;
+exports.makeRunEndedReader = makeRunEndedReader;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const core_1 = require("@looply/core");
+const git_driver_1 = require("./git-driver");
+const ledger_store_1 = require("./ledger-store");
+const run_ended_1 = require("./run-ended");
+const run_start_marks_1 = require("./run-start-marks");
+const trusted_git_1 = require("./trusted-git");
+const workspace_1 = require("./workspace");
+/**
+ * Whether `checkout` is a place this project's runs execute: its main checkout,
+ * or a workspace under its own workspaces root that is (still) a checkout of
+ * the same repository.
+ */
+function isProjectExecutionRoot(cwd, checkout, home = (0, node_os_1.homedir)()) {
+    const main = (0, node_path_1.resolve)((0, trusted_git_1.mainWorktreeRoot)(cwd) ?? cwd);
+    const wanted = (0, node_path_1.resolve)(checkout);
+    if (wanted === main)
+        return { ok: true };
+    const root = (0, node_path_1.resolve)((0, workspace_1.workspacesRoot)(cwd, home));
+    const rel = (0, node_path_1.relative)(root, wanted);
+    if (rel === '' || rel.startsWith('..') || (0, node_path_1.isAbsolute)(rel)) {
+        return { ok: false, because: `${checkout} is not this project's checkout and not under its workspaces root` };
+    }
+    // A workspace that still exists must be a checkout of THIS repository. One
+    // that no longer exists cannot be read anyway, and the ledger read says so.
+    if ((0, node_fs_1.existsSync)(wanted) && (0, trusted_git_1.repoIdentityPath)(wanted) !== (0, trusted_git_1.repoIdentityPath)(cwd)) {
+        return { ok: false, because: `${checkout} is not a checkout of this repository` };
+    }
+    return { ok: true };
+}
+/** The checkout the project's records say this run executes in, if any. */
+function locateRunCheckout(runId, records) {
+    const rec = records.record !== null && records.record.kind !== 'unreadable' ? records.record : null;
+    const fromRecord = rec?.record.workspace;
+    const fromMark = records.mark?.workspace;
+    if (fromRecord !== undefined && fromMark !== undefined && (0, node_path_1.resolve)(fromRecord) !== (0, node_path_1.resolve)(fromMark)) {
+        return {
+            kind: 'ambiguous',
+            because: `run ${runId} is recorded in two checkouts (${fromRecord} and ${fromMark})`,
+        };
+    }
+    const checkout = fromRecord ?? fromMark;
+    if (checkout === undefined)
+        return { kind: 'legacy' };
+    return { kind: 'located', checkout, liveness: rec === null ? 'released' : rec.kind };
+}
+/**
+ * The daemon's `runEnded` dependency, over the real records.
+ *
+ * ONE factory, used by the daemon and by the end-to-end proof alike, so the
+ * proof exercises the reader the daemon actually runs rather than a stand-in
+ * that happens to agree.
+ */
+function makeRunEndedReader(deps) {
+    const fs = deps.fs ?? ledger_store_1.nodeLedgerFs;
+    const home = deps.home ?? (0, node_os_1.homedir)();
+    const projectState = (0, git_driver_1.projectStateDir)(deps.cwd);
+    const marks = deps.marks ?? (() => new run_start_marks_1.RunStartMarks(projectState, ledger_store_1.nodeLedgerFs));
+    const registry = deps.registry ?? (() => new workspace_1.RunRegistry(projectState, deps.probe ?? workspace_1.nodeProbe));
+    return async (runId) => {
+        if (runId === '')
+            return { ok: false, because: 'no run was named' };
+        let record = null;
+        for (const entry of registry().list()) {
+            if (entry.kind === 'unreadable')
+                continue;
+            if (entry.record.runId === runId) {
+                record = entry;
+                break;
+            }
+        }
+        const m = marks();
+        await m.load();
+        const where = locateRunCheckout(runId, { record, mark: m.findByRun(runId) });
+        if (where.kind === 'ambiguous')
+            return { ok: false, because: where.because };
+        if (where.kind === 'legacy')
+            return collapse(await (0, run_ended_1.readRunEnded)(projectState, fs, runId));
+        const allowed = isProjectExecutionRoot(deps.cwd, where.checkout, home);
+        if (!allowed.ok)
+            return { ok: false, because: `cannot read run ${runId}'s ledger: ${allowed.because}` };
+        const stateDir = (0, git_driver_1.executionStateDir)(where.checkout);
+        let text;
+        try {
+            text = await fs.readFile(`${stateDir}/events.jsonl`);
+        }
+        catch (e) {
+            return { ok: false, because: `the run ledger could not be read (${e.message})` };
+        }
+        const events = text === null || text.length === 0 ? [] : (0, core_1.parseLines)(text).events;
+        let started = false;
+        for (const e of events) {
+            if (e.runId !== runId)
+                continue;
+            if (e.kind === 'run.ended')
+                return { ok: true, ended: true };
+            if (e.kind === 'run.started')
+                started = true;
+        }
+        if (started)
+            return { ok: true, ended: false };
+        // No trace of this run on the ledger it executes in.
+        switch (where.liveness) {
+            case 'active':
+                // Registered and alive: it has not reached `run.started` yet.
+                return { ok: true, ended: false };
+            case 'unknown':
+                return { ok: false, because: `run ${runId} has not written to its ledger and its process cannot be judged` };
+            case 'orphaned':
+            case 'released':
+                return {
+                    ok: false,
+                    because: `run ${runId} is gone and left no ending on its ledger at ${where.checkout} — ` +
+                        'waiting for stale-run recovery to close it',
+                };
+            default: {
+                const never = where.liveness;
+                throw new Error(`no answer for liveness ${String(never)}`);
+            }
+        }
+    };
+}
+function collapse(out) {
+    return out.ok ? { ok: true, ended: out.ended } : { ok: false, because: out.because };
+}
+//# sourceMappingURL=run-ending-locator.js.map

package/dist/run-ending-locator.js.map

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

package/dist/run-launcher.d.ts

@@ -0,0 +1,459 @@
+import type { RunRefusalCode } from '@looply/core';
+import { type LeaseState } from './run-lease';
+/**
+ * Starting one of the CLI's long jobs — a run, a scan — because the phone
+ * asked for it.
+ *
+ * The daemon acks a command only when it carried it out, so the whole question
+ * here is when a spawned job counts as started. It is *not* the moment `spawn`
+ * returns: node reports a missing or unrunnable binary asynchronously, through
+ * an `error` event a tick later, so acking on the handle alone shows the phone
+ * a tick for a job that never existed. A job that starts and dies immediately —
+ * a bad `--hours`, a config the CLI refuses — is the same lie with extra steps.
+ * So the launcher watches the child for a settling window and reports started
+ * only if nothing came back saying otherwise.
+ */
+/** The slice of a child process the launcher needs; callbacks may fire in any order. */
+export interface LaunchHandle {
+    pid: number | undefined;
+    /** `code` is null when the process died to a signal rather than exiting. */
+    onExit(cb: (code: number | null) => void): void;
+    /** Spawn-level failure: the run could not be started at all. */
+    onError(cb: (err: Error) => void): void;
+    /** Stop the parent waiting on this child, so the daemon can exit without it. */
+    release(): void;
+}
+export interface RunLauncherDeps {
+    spawn(args: readonly string[]): LaunchHandle;
+    sleep(ms: number): Promise<void>;
+    /** How long to watch for a spawn failure before calling the child up. */
+    settleMs?: number;
+    /**
+     * Durable proof that a given request's run actually started.
+     *
+     * Absent in callers that cannot read it; then a run can never be PROVEN and
+     * the request simply stays outstanding. That is the safe degradation — it
+     * delays an answer, and can never duplicate a run, because the lease is what
+     * stops a second runner.
+     */
+    provenStart?(requestId: string): Promise<{
+        runId: string;
+    } | null>;
+    /**
+     * What the durable run lease says about this working tree, if anything.
+     *
+     * Advisory only — the run process is what actually takes the lease, and it
+     * refuses itself if it cannot. This exists so the daemon can answer the phone
+     * honestly instead of spawning a child that exits a moment later with a
+     * message nobody sees. It also survives a daemon restart, which the
+     * in-memory map above cannot: that is the whole duplicate-runner window.
+     */
+    peekLease?(): Promise<LeaseState>;
+    /**
+     * The lease of ONE checkout, for a run the coordinator placed there.
+     *
+     * 🔴 `peekLease()` ANSWERS ABOUT THE PROJECT'S OWN CHECKOUT AND NOTHING ELSE,
+     * so asking it about a second workspace asks the wrong file: a live run in the
+     * main checkout refused a launch into an empty workspace beside it. That is
+     * the single-run behaviour which made N-way scheduling impossible however the
+     * scheduler decided.
+     *
+     * Optional: a launcher without it cannot place runs in workspaces, and behaves
+     * exactly as it always has.
+     */
+    peekLeaseAt?(workspace: string): Promise<LeaseState>;
+    /**
+     * Why this request's run refused, in the run's OWN words — and which refusal
+     * it was.
+     *
+     * The child is spawned with `stdio: 'ignore'`, so the only thing this process
+     * can observe of it is an exit code — and exit 3 says "terminal", not why.
+     * The run writes its reason down where a reader can find it; this reads it.
+     *
+     * The `code` is what makes a refusal actionable by something other than a
+     * person. It is optional because a mark written before 6D2A has none, and
+     * because a refusal that cannot be read at all still degrades to the plainer
+     * wording below. A missing reason costs a sentence; a missing CODE costs the
+     * right to conclude anything from the refusal, which is exactly the caution
+     * the caller should exercise.
+     */
+    refusalOf?(requestId: string): Promise<{
+        reason: string;
+        code?: RunRefusalCode;
+    } | null>;
+}
+export type LaunchResult = 
+/**
+ * PROVEN. Durable evidence says this command's run crossed the accepted start
+ * boundary — `run.started` is in the ledger and the mark names this command.
+ *
+ * Nothing else may report this. A child that is merely alive has proven
+ * nothing: a goal-bound run resolves its goal, takes the lease, adopts items
+ * and verifies drafts before a Run exists, and every one of those can still
+ * end without one, minutes later.
+ */
+{
+    started: true;
+    already: boolean;
+    pid: number | undefined;
+    runId?: string;
+}
+/**
+ * A child for this command is alive and has not yet proven anything.
+ *
+ * The honest middle state, and the one the old contract was missing: it
+ * collapsed this into `started: true` after 750ms and let the daemon ack a
+ * command terminally on it. Left queued, so the next poll can ask again — and
+ * the launcher will not spawn a second child for the same request.
+ */
+ | {
+    started: false;
+    waiting: true;
+    reason: string;
+    /**
+     * The child that was created, when one was.
+     *
+     * A run is held to proof, so a successful spawn reports `waiting` rather
+     * than `started` — the run has not begun until the ledger says so. That
+     * left the caller unable to tell "a child is starting" from "no child was
+     * made", which are opposite answers for anything counting tries. The pid
+     * is the only honest evidence, so it travels with the answer.
+     */
+    spawnedPid?: number;
+} | {
+    started: false;
+    reason: string;
+}
+/**
+ * Refused for a reason retrying cannot fix. Distinct from `started: false`,
+ * which redelivers: since commands became genuinely redeliverable, a refusal
+ * offered again every three seconds for an hour is a storm, not a service.
+ *
+ * `terminal` MEANS "stop asking on this cycle". It does NOT mean the goal is
+ * finished, and the difference is the whole of 6D2A's caution: three of the
+ * sites that set it are machine-local CONTENTION — a clash with a live run,
+ * a lease that cannot be probed — which are true right now and false ten
+ * minutes from now. Only a refusal the RUN ITSELF made carries a `code`, and
+ * only a code may be turned into a statement about the goal. See
+ * {@link asStartResult}.
+ */
+ | {
+    started: false;
+    reason: string;
+    terminal: true;
+    code?: RunRefusalCode;
+};
+/**
+ * WHO ASKED FOR THIS START, AND UNDER WHAT AUTHORITY.
+ *
+ * The two are genuinely different acts and the machine must not lose track of
+ * which it is carrying out. A person tapping Start authorizes ONE run, and the
+ * server has a durable row for it that must be acked. A controller spending
+ * ordinal N of a grant authorizes one run too, but there is no row, nothing to
+ * ack, and no person in the loop at that instant — the person's act was
+ * authorizing the grant, earlier.
+ *
+ * Modelled as a discriminated union rather than an optional field so that every
+ * Start has to say which it is. The alternative — an optional `controllerId`
+ * beside an optional `commandId` — permits both, permits neither, and makes
+ * "who authorized this" a question with four answers instead of two.
+ */
+export type StartOrigin = 
+/**
+ * A person tapped Start. `commandId` is the server row to answer.
+ *
+ * No attempt number, deliberately. A human Start is already bounded by the
+ * server's one-hour redelivery window, and giving it a second, smaller cap
+ * would change a path that has worked for phases in a way nobody asked for.
+ */
+{
+    kind: 'human-command';
+    commandId: string;
+}
+/**
+ * A controller spent one bounded ordinal of a grant a person authorized
+ * earlier.
+ *
+ * `attempt` counts tries at THIS request, not requests. Attempts 1, 2 and 3
+ * of ordinal N all carry the same `requestId`: they are three tries at
+ * establishing one Start, not three Starts, and every durable fact about it
+ * is filed under the one id. It is required here because an autonomous Start
+ * has no server row and therefore no redelivery window to bound it.
+ */
+ | {
+    kind: 'autonomy';
+    controllerId: string;
+    ordinal: number;
+    attempt: number;
+};
+/**
+ * ONE ATTEMPT TO START A BOUNDED RUN.
+ *
+ * `requestId` is the durable identity of the attempt and the key under which
+ * every durable fact about it is filed: the lease's `startedByCommandId`, the
+ * start mark that proves a Run began, the refusal mark that says why one did
+ * not. It is deliberately opaque to everything below this line — the launcher,
+ * the child, the marks and the lease all treat it as a string, and none of them
+ * asks where it came from.
+ *
+ * For a human Start it IS the command id, which keeps every existing record
+ * readable and every existing behaviour identical. For an autonomous Start it
+ * is `autonomyStartId(controllerId, ordinal)`, which is derived rather than
+ * minted, so two daemons that both decide ordinal N is due compute the same
+ * string and file their facts in the same place.
+ */
+export interface StartRequest extends StartPayload {
+    requestId: string;
+    origin: StartOrigin;
+    /**
+     * WHICH CHECKOUT THIS RUN IS FOR.
+     *
+     * 🔴 WITHOUT IT THE LAUNCHER IS SINGLE-RUN BY CONSTRUCTION, whatever the
+     * scheduler decides. `live` was keyed by the literal string `'run'`, so a
+     * second launch found the first and reported "already going"; and the lease
+     * check below peeked THE lease — the project's — so a second launch was
+     * refused by a run in a different checkout entirely. `decideSchedule` has
+     * been assigning a workspace per start since it was written
+     * (`ObservedPremise.workspace`) and nothing carried it here.
+     *
+     * ⚠️ ABSENT IS THE WHOLE OF THE COMPATIBILITY GUARANTEE. With no workspace
+     * the job key is `'run'`, the lease peeked is the project's, and no `--in` is
+     * passed — byte-identical to every launch this has ever made. Simple Mode and
+     * the phone's Start are unchanged.
+     */
+    workspace?: string;
+}
+/**
+ * WHAT CAME OF ONE ATTEMPT, as something other than a person can read it.
+ *
+ * {@link LaunchResult} is shaped for the daemon's command handler, which has
+ * only ever needed to answer "ack, refuse, or leave it queued". A controller
+ * needs a sharper question answered: may I conclude something about the GOAL
+ * from this?
+ *
+ * The line that matters runs between `refused` and `blocked`. A `refused` came
+ * from the run itself deciding, in a `RunRefused` carrying a code, that this
+ * Start will not produce a Run — that is a statement about the work. A
+ * `blocked` is the machine saying "not now": a clash with a live run, a lease
+ * it cannot probe, a mark it could not read. Both are terminal for THIS poll;
+ * only the first may ever become "the goal is satisfied".
+ */
+export type StartResult = 
+/** Durable proof: `run.started` is in the ledger and the mark names this request. */
+{
+    kind: 'run-started';
+    runId: string;
+}
+/** A child is alive for this request and has proven nothing yet. Ask again. */
+ | {
+    kind: 'pending';
+    reason: string;
+}
+/** The RUN decided. Only this arm may drive a statement about the goal. */
+ | {
+    kind: 'refused';
+    code: RunRefusalCode;
+    reason: string;
+}
+/** The machine could not start it NOW. Never a statement about the goal. */
+ | {
+    kind: 'blocked';
+    reason: string;
+}
+/** The attempt failed and may be retried under whatever bound the caller holds. */
+ | {
+    kind: 'failed';
+    reason: string;
+};
+/**
+ * The same answer, restated for a caller that must decide rather than report.
+ *
+ * A pure projection, so there is exactly one implementation of "what happened"
+ * and this is a view onto it — not a second opinion. The daemon's command
+ * handler keeps reading {@link LaunchResult} directly and is untouched.
+ *
+ * The two rules worth stating out loud:
+ *
+ *   A terminal result with NO code is `blocked`, never `refused`. That covers
+ *   every contention case and also the case where the run did refuse but its
+ *   mark could not be read — in which case the honest answer is "I do not know
+ *   why", and a caller that may end a person's grant on the strength of this
+ *   must not be handed a guess.
+ *
+ *   `started: true` without a runId is `pending`, not `run-started`. For a run
+ *   that can only ever be true of a job held to no proof contract, and a
+ *   controller that treated it as a Run would wait for an ending that no
+ *   ledger will ever carry.
+ */
+export declare function asStartResult(r: LaunchResult): StartResult;
+/** What the command handler needs from a launcher, so it can be stubbed. */
+export interface RunStarter {
+    start(req: StartRequest): Promise<LaunchResult>;
+    /**
+     * Optional for the same reason `starter` itself is optional on the handler: a
+     * caller that can spawn a run but not a scan must leave `scan` unacked rather
+     * than ack something it never did.
+     */
+    scan?(): Promise<LaunchResult>;
+}
+/**
+ * Long enough for an ENOENT or an argument the CLI refuses outright to come
+ * back, short enough that the phone's tap still feels answered.
+ */
+export declare const DEFAULT_SETTLE_MS = 750;
+export declare class RunLauncher implements RunStarter {
+    private readonly deps;
+    /**
+     * Job name → the child believed to still be running. Absent once it exits.
+     *
+     * It remembers `goalId` because "a run is already going" is no longer a
+     * complete answer: a second start-run naming a DIFFERENT goal is a different
+     * request, and answering it with the run that is already here would ack a goal
+     * that never ran.
+     */
+    private readonly live;
+    /**
+     * How a child this launcher spawned actually ended, by the command that asked
+     * for it.
+     *
+     * The child is detached and unref'd, so `launch` has long returned by the time
+     * it exits — and under the old contract nobody ever read the exit code again.
+     * A run that refuses its goal after a second of preflight exits 3, and this is
+     * what carries that answer to the next poll.
+     *
+     * In memory only, and deliberately: it is an optimisation, not the record. A
+     * daemon restart forgets, relaunches once, and the child refuses again — one
+     * wasted spawn rather than a wrong ack.
+     */
+    private readonly ended;
+    constructor(deps: RunLauncherDeps);
+    /**
+     * What to tell the daemon a terminal refusal was, given what this process saw.
+     *
+     * `fallback` is what the launcher can see by itself — an exit code — and it
+     * is what shipped before the run could say more. The run's own reason is
+     * preferred whenever it left one for THIS command: the whole point is that
+     * "the run exited — exit 3" and "this goal's work is done" are not the same
+     * answer to somebody waiting on their phone.
+     *
+     * Keyed by command id, so a refusal can only ever be reported against the
+     * request that produced it. Never throws: a reason that cannot be read leaves
+     * the refusal exactly as truthful as it was, just less specific.
+     */
+    private refusalMark;
+    /**
+     * Is any run live in this process?
+     *
+     * ⚠️ ANY CHECKOUT, NOT ONLY THE MAIN ONE. Job keys are `run` for an unplaced
+     * run and `run:<workspace>` for one a coordinator placed, and a caller asking
+     * "is a run going" means any of them.
+     */
+    isRunning(): boolean;
+    start(req: StartRequest): Promise<LaunchResult>;
+    /**
+     * `looply scan`, as a child, so the lens passes stream into the ledger and
+     * reach the phone rather than being twenty silent minutes.
+     */
+    scan(): Promise<LaunchResult>;
+    private launch;
+}
+/**
+ * Just enough of a Start to tell two of them apart.
+ *
+ * Named for what it is: this pair is compared, never executed. The thing that
+ * IS executed is {@link StartRequest} below, and conflating the two is how the
+ * launcher came to describe a server command row in a comment about identity.
+ */
+export interface StartIdentity {
+    /** The execution identity of the request. See {@link StartRequest.requestId}. */
+    commandId?: string | undefined;
+    goalId?: string | undefined;
+}
+/**
+ * Whether an already-running job answers the Start that just arrived.
+ *
+ * "A run is already going here" used to be a complete answer, and it was: both
+ * callers had asked for a run to be in progress, and one was. A goal makes it
+ * incomplete, and `itemIds` makes goal identity insufficient too — these are
+ * DIFFERENT requests:
+ *
+ *     C1  goal G, items [A]        C2  goal G, items [B]
+ *
+ * C2 is not satisfied because a G-bound run happens to exist; it asked for work
+ * that run will never pick. So the identity of a Start is its REQUEST, not its
+ * goal.
+ *
+ * That is sound for a human Start because the command row is durable and its
+ * payload cannot mutate after creation — the only writes to an existing row are
+ * the ack and the expiry sweep — so one command id means one unchanging request.
+ * It is sound for an autonomous Start for a different reason with the same
+ * force: `autonomyStartId(C, N)` is derived from a controller id and an ordinal
+ * whose reservation receipt is created with O_EXCL and never rewritten, so one
+ * request id there also means one unchanging request. Neither depends on the
+ * other, and the launcher does not need to know which it is holding.
+ *
+ * Returns the refusal text, or `null` when the live run genuinely satisfies it.
+ */
+export declare function refuseStart(want: StartIdentity, live: StartIdentity): string | null;
+/**
+ * Everything a start-run payload is allowed to say, narrowed for the machine.
+ *
+ * The mirror of the server's `normaliseStart`, and deliberately not trusting
+ * it. The payload travels phone → server → Json column → Redis → daemon
+ * untyped, and this process may be an older or newer build than the one that
+ * wrote the row.
+ */
+export interface StartPayload {
+    hours?: number;
+    goalId?: string;
+    goalVersion?: number;
+    itemIds?: string[];
+    /**
+     * The answer this Start is picking up, when a person is starting again after
+     * one.
+     *
+     * AN ID AND NOTHING ELSE. The run resolves it against the server itself, for
+     * the same reason it resolves its own goal: the daemon CARRIES these values
+     * and the run process is what decides whether they still mean anything.
+     * Sending the action, the wording or the outcome down argv would be a second,
+     * unverified copy of a decision — and argv is also length-capped and publicly
+     * visible, which is why the adoption list is bounded a few lines below.
+     *
+     * NEVER SET BY A MODEL, and never by the phone: it comes from the gate that
+     * read the server, and it is claimed exclusively before this Start exists.
+     */
+    resumedFromApprovalId?: string;
+    governedApprovalId?: string;
+}
+/**
+ * How many items one Start may adopt.
+ *
+ * The adoption list travels to the run process on its command line, and an
+ * argv that exceeds the OS limit produces a spawn failure rather than a
+ * refusal — a command nobody can carry out and nobody can read. A bound the
+ * daemon states is better than one the kernel enforces.
+ */
+export declare const MAX_ADOPTED_ITEMS = 200;
+/**
+ * What a start-run payload asks for, or why this build will not carry it out.
+ *
+ * ONE reader, deliberately. A second narrowing somewhere else is how a
+ * malformed goal silently becomes an UNBOUND run — which would work the whole
+ * queue while the phone waits for a goal that never binds. A value that is
+ * present but unusable is never "no goal": the whole point of the union is
+ * that the caller cannot accidentally treat the two the same way.
+ *
+ * `hours` is the exception and stays lenient, because the config carries a
+ * budget to fall back on. Nothing falls back for a goal.
+ */
+export type StartRead = {
+    ok: true;
+    start: StartPayload;
+} | {
+    ok: false;
+    problem: string;
+};
+export declare function readStartPayload(payload: unknown): StartRead;
+export declare function hoursFromPayload(payload: unknown): number | undefined;
+export declare function nodeRunLauncher(cwd: string, stateDir?: string): RunLauncher;
+//# sourceMappingURL=run-launcher.d.ts.map

package/dist/run-launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-launcher.d.ts","sourceRoot":"","sources":["../src/run-launcher.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAA6C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAMzF;;;;;;;;;;;;GAYG;AAEH,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAAC;IAChD,gEAAgE;IAChE,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IACxC,gFAAgF;IAChF,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;IAC7C,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACnE;;;;;;;;OAQG;IACH,SAAS,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAClC;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACrD;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CAC1F;AAED,MAAM,MAAM,YAAY;AACtB;;;;;;;;GAQG;AACD;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;AAC9E;;;;;;;GAOG;GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACD;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACpC;;;;;;;;;;;;GAYG;GACD;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,cAAc,CAAA;CAAE,CAAC;AAE9E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW;AACrB;;;;;;GAMG;AACD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;AAC9C;;;;;;;;;GASG;GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW;AACrB,qFAAqF;AACnF;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACxC,+EAA+E;GAC7E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACrC,2EAA2E;GACzE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAC3D,4EAA4E;GAC1E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACrC,mFAAmF;GACjF;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,YAAY,GAAG,WAAW,CAa1D;AAED,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAChD;;;;OAIG;IACH,IAAI,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;CAChC;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AA2BrC,qBAAa,WAAY,YAAW,UAAU;IA0BhC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAzBjC;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkE;IAEvF;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4D;gBAErD,IAAI,EAAE,eAAe;IAElD;;;;;;;;;;;;OAYG;YACW,WAAW;IAczB;;;;;;OAMG;IACH,SAAS,IAAI,OAAO;IAId,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAoHrD;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC;YAUrB,MAAM;CA4JrB;AAoCD;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAiBnF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;;;;;;OAaG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3F,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAqD5D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAKrE;AAGD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,CA8F3E"}