looply-cli 0.0.0-stage → 0.2.0

package/dist/approval-gate-read.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPROVAL_PAGE = void 0;
+exports.readApprovalGate = readApprovalGate;
+const core_1 = require("@looply/core");
+/**
+ * How many rows to ask for.
+ *
+ * A pursuit at one version accumulates approvals slowly — a run raises at most
+ * one and then stops — so this is generous rather than tuned. It exists at all
+ * because the route's own default is 50 and silently taking the newest 50 of a
+ * larger set would be a gate that stops seeing the oldest outstanding question.
+ */
+exports.APPROVAL_PAGE = 200;
+/**
+ * A row is only usable if every field the decision reads is the right shape.
+ *
+ * `request()` casts the parsed body without looking at it, so a captive portal
+ * or a proxy interstitial is a perfectly successful response carrying something
+ * else entirely. The goal mirror guards this by hand for the same reason, and a
+ * question about human authority is a worse place to find out.
+ */
+function projectionOf(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const o = raw;
+    if (typeof o['id'] !== 'string' || o['id'].length === 0)
+        return null;
+    if (typeof o['state'] !== 'string' || o['state'].length === 0)
+        return null;
+    if (typeof o['expiresAt'] !== 'string' || o['expiresAt'].length === 0)
+        return null;
+    if (Number.isNaN(Date.parse(o['expiresAt'])))
+        return null;
+    const goalId = o['goalId'];
+    const goalVersion = o['goalVersion'];
+    if (goalId !== null && typeof goalId !== 'string')
+        return null;
+    if (goalVersion !== null && typeof goalVersion !== 'number')
+        return null;
+    const execution = executionOf(o['execution']);
+    // `undefined` is the one answer that is not a shape: it means the row came
+    // back malformed, which is not the same as an approval with no attempt.
+    if (execution === undefined)
+        return null;
+    return {
+        id: o['id'],
+        state: o['state'],
+        goalId: goalId ?? null,
+        goalVersion: goalVersion ?? null,
+        expiresAt: o['expiresAt'],
+        execution,
+    };
+}
+/**
+ * The attempt made under this approval, or its absence, or a refusal.
+ *
+ * THREE ANSWERS AND NOT TWO, because absent and malformed must not lead to the
+ * same place. An approval nobody has claimed genuinely has no attempt; a row
+ * whose attempt this build cannot read is a row that may mean an effect
+ * happened, and reading it as "none" would let a pursuit carry on past one.
+ *
+ * `state` is left as a plain string on purpose. `deriveApprovalGate` refuses a
+ * word this build does not know rather than a parser here silently widening the
+ * set — the same division of labour the approval's own state already has.
+ */
+function executionOf(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const e = raw;
+    if (typeof e['state'] !== 'string' || e['state'].length === 0)
+        return undefined;
+    const assigned = e['resultAssignedRunId'];
+    if (assigned !== null && assigned !== undefined && typeof assigned !== 'string')
+        return undefined;
+    const acknowledged = e['acknowledged'];
+    if (acknowledged !== undefined && typeof acknowledged !== 'boolean')
+        return undefined;
+    const resolved = e['resolved'];
+    if (resolved !== undefined && typeof resolved !== 'boolean')
+        return undefined;
+    return {
+        state: e['state'],
+        resultAssignedRunId: assigned ?? null,
+        acknowledged: acknowledged === true,
+        /**
+         * ABSENT MEANS NOT RESOLVED, and that is the safe direction here rather
+         * than merely the convenient one. An older server does not send this field
+         * at all; reading its silence as `true` would free a pursuit nobody has
+         * dealt with, which is the exact failure the two dead ends exist to
+         * prevent. Reading it as `false` only holds, and holding is recoverable.
+         */
+        resolved: resolved === true,
+    };
+}
+async function readApprovalGate(server, input) {
+    let rows;
+    try {
+        rows = await server.projectApprovals(input.projectId, { goalId: input.goalId, goalVersion: input.goalVersion }, exports.APPROVAL_PAGE);
+    }
+    catch (e) {
+        return { kind: 'unknown', because: `the approvals could not be read (${e.message})` };
+    }
+    if (!Array.isArray(rows)) {
+        // A 200 is not an answer.
+        return { kind: 'unknown', because: 'the server answered with something that is not a list' };
+    }
+    const read = [];
+    for (const raw of rows) {
+        const p = projectionOf(raw);
+        if (p === null) {
+            // ONE BAD ROW POISONS THE ANSWER, and deliberately so. Skipping it would
+            // mean deciding a pursuit may proceed while holding a row nobody could
+            // read — which is the fail-open this whole file exists to prevent.
+            return { kind: 'unknown', because: 'the server returned an approval this build cannot read' };
+        }
+        read.push(p);
+    }
+    // ASKED AFTER THE ROWS ARE IN HAND, because until then there is nothing to
+    // ask about. A machine cannot know which answers to look for until it knows
+    // which exist.
+    let given = new Set();
+    if (input.consumed !== undefined) {
+        const claims = await input.consumed(read.map((a) => a.id));
+        if (!claims.ok)
+            return { kind: 'unknown', because: claims.because };
+        given = claims.consumed;
+    }
+    return (0, core_1.deriveApprovalGate)({
+        goalId: input.goalId,
+        goalVersion: input.goalVersion,
+        approvals: read.map((a) => (given.has(a.id) ? { ...a, consumed: true } : a)),
+        now: input.now,
+    });
+}
+//# sourceMappingURL=approval-gate-read.js.map

package/dist/approval-gate-read.js.map

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

package/dist/approval-resolution.d.ts

@@ -0,0 +1,87 @@
+import { type ResolvedOutcome } from '@looply/core';
+import type { ServerApprovalRow } from './server-client';
+/**
+ * WHAT A PERSON SAID NO TO, TOLD TO THE RUN THAT ASKED.
+ *
+ * A pursuit stopped because it wanted something only a person may authorise.
+ * The person answered — denied it, took it back, or let the window close — and
+ * somebody has now started the pursuit again. This is what that new run is
+ * told, and the shape of it is the whole point.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * IT IS READ FROM THE SERVER, NOT CARRIED
+ *
+ * The daemon puts ONE thing on the command line: an id. Everything the model
+ * ends up being told is fetched here, from the row the person's decision was
+ * written to. The alternative — serialising the outcome and the wording into
+ * argv — makes a second copy of a decision, on a channel that is publicly
+ * visible and length-capped, and a second copy is a thing that can disagree
+ * with the first.
+ *
+ * THE HUMAN LINE COMES FROM THE SERVER'S OWN FORMATTER. `display` is rendered
+ * by 7B1's `displayAction`, which is the single description authority — the
+ * same function that produced the sentence the person was actually shown.
+ * Assembling one here out of the action type and its fields would be a second
+ * wording, free to drift from what somebody read before they tapped Deny.
+ *
+ * AND IT IS CHECKED AGAINST THIS RUN. A resolution names a project, a pursuit
+ * and a version; if any of them is not this run's, it is somebody else's answer
+ * and this run is told nothing. That check is why the id alone is safe to
+ * carry: forging it buys nothing, because the row it names must still belong
+ * to the pursuit the run is bound to.
+ */
+export interface ApprovalResolutionContext {
+    readonly approvalId: string;
+    readonly actionType: string;
+    readonly actionFingerprint: string;
+    readonly outcome: ResolvedOutcome;
+    /** The one line the person was shown, from the server's own formatter. */
+    readonly display: string;
+    /**
+     * The owner's own words about their decision, when they left any.
+     *
+     * NOT AUTHORITY, and the same kind of thing as an action's `note`: it may
+     * help a model plan around a refusal — "not on a Friday" is worth knowing —
+     * and it decides nothing. Nothing branches on it.
+     */
+    readonly note?: string;
+}
+export type ResolutionRead = {
+    readonly ok: true;
+    readonly resolution: ApprovalResolutionContext;
+}
+/**
+ * The answer could not be established.
+ *
+ * NOT a licence to carry on. A run resumed on a refusal it could not read is
+ * a run that will plan as though nothing was refused — and the likeliest
+ * thing it plans is asking for the same action again.
+ */
+ | {
+    readonly ok: false;
+    readonly because: string;
+};
+/** Just enough of the client to fetch one. Injected so a test can fail it. */
+export interface ResolutionReader {
+    projectApproval(projectId: string, approvalId: string): Promise<ServerApprovalRow>;
+}
+export interface ResolutionFor {
+    readonly projectId: string;
+    readonly goalId: string;
+    readonly goalVersion: number;
+    readonly now: number;
+}
+export declare function readApprovalResolution(server: ResolutionReader, approvalId: string, run: ResolutionFor): Promise<ResolutionRead>;
+/**
+ * The block a resumed run's model is given, as plain lines.
+ *
+ * PROSE, AND DELIBERATELY NOT JSON. The implementer's transcript is scanned for
+ * a structured declaration, and the scan takes the FIRST one it finds so that a
+ * turn cannot ask for two consequential actions. A prompt that illustrated the
+ * shape of a request would be a decoy an echoing model files for real.
+ *
+ * The structured half is the context object above, which the run holds; this is
+ * only how it reads.
+ */
+export declare function describeResolution(r: ApprovalResolutionContext): string;
+//# sourceMappingURL=approval-resolution.d.ts.map

package/dist/approval-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-resolution.d.ts","sourceRoot":"","sources":["../src/approval-resolution.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0D,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAC5G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,yBAAyB,CAAA;CAAE;AACvE;;;;;;GAMG;GACD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACpF;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,aAAa,GACjB,OAAO,CAAC,cAAc,CAAC,CAgDzB;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,yBAAyB,GAAG,MAAM,CAmBvE"}

package/dist/approval-resolution.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readApprovalResolution = readApprovalResolution;
+exports.describeResolution = describeResolution;
+const core_1 = require("@looply/core");
+async function readApprovalResolution(server, approvalId, run) {
+    let row;
+    try {
+        row = await server.projectApproval(run.projectId, approvalId);
+    }
+    catch (e) {
+        return { ok: false, because: `the decision could not be read (${e.message})` };
+    }
+    if (row === null || typeof row !== 'object' || typeof row.id !== 'string') {
+        return { ok: false, because: 'the server answered with something that is not an approval' };
+    }
+    if (row.id !== approvalId) {
+        return { ok: false, because: `the server returned approval ${row.id}, not ${approvalId}` };
+    }
+    if (row.projectId !== run.projectId) {
+        return { ok: false, because: 'that decision belongs to another project' };
+    }
+    // SOMEBODY ELSE'S ANSWER. A resolution is about one pursuit at one version,
+    // and telling a run about a decision made for a different one would be
+    // telling it something untrue about its own work.
+    if (row.goalId !== run.goalId || row.goalVersion !== run.goalVersion) {
+        return { ok: false, because: 'that decision was made for a different pursuit' };
+    }
+    if (typeof row.display !== 'string' || typeof row.actionType !== 'string') {
+        return { ok: false, because: 'the server returned an approval this build cannot read' };
+    }
+    const outcome = outcomeOf(row, run.now);
+    if (outcome === null) {
+        // Still live, or already taken. Either way there is nothing to plan around
+        // — and a run resumed on one of those should never have been started, which
+        // is the gate's job and is asserted separately.
+        return { ok: false, because: `that approval is ${row.state}, which is not something to plan around` };
+    }
+    return {
+        ok: true,
+        resolution: {
+            approvalId: row.id,
+            actionType: row.actionType,
+            actionFingerprint: row.actionFingerprint,
+            outcome,
+            display: row.display,
+            ...(typeof row.decisionNote === 'string' && row.decisionNote.length > 0
+                ? { note: row.decisionNote }
+                : {}),
+        },
+    };
+}
+/**
+ * Which answer this is, with the clock applied.
+ *
+ * The single-approval route settles expiry as it reads, so `state` here is
+ * usually already right — but the check costs nothing and keeps this file
+ * honest on its own, rather than correct only because of what another service
+ * happened to do first.
+ */
+function outcomeOf(row, now) {
+    if (!(0, core_1.isApprovalState)(row.state))
+        return null;
+    if (core_1.RESOLVED_APPROVAL_STATES.includes(row.state))
+        return row.state;
+    if (row.state === 'claimed')
+        return null;
+    return (0, core_1.isExpiredAt)(new Date(now), new Date(row.expiresAt)) ? 'expired' : null;
+}
+/**
+ * The block a resumed run's model is given, as plain lines.
+ *
+ * PROSE, AND DELIBERATELY NOT JSON. The implementer's transcript is scanned for
+ * a structured declaration, and the scan takes the FIRST one it finds so that a
+ * turn cannot ask for two consequential actions. A prompt that illustrated the
+ * shape of a request would be a decoy an echoing model files for real.
+ *
+ * The structured half is the context object above, which the run holds; this is
+ * only how it reads.
+ */
+function describeResolution(r) {
+    const said = r.outcome === 'denied'
+        ? 'was refused'
+        : r.outcome === 'revoked'
+            ? 'was approved and then taken back'
+            : 'was never answered, and the window closed';
+    return [
+        'A PREVIOUS RUN ASKED FOR SOMETHING THAT NEEDS A PERSON, AND IT ' + said.toUpperCase() + '.',
+        '',
+        `  what was asked for : ${r.display}`,
+        `  the answer         : ${r.outcome}`,
+        ...(r.note === undefined ? [] : [`  what they said     : ${r.note}`]),
+        '',
+        'Plan around it. Do not ask for the same thing again — the answer will be the',
+        'same, and asking would stop this run for nothing. Either find a way to the',
+        'goal that does not need it, or finish the work that does not depend on it and',
+        'say plainly what is left.',
+    ].join('\n');
+}
+//# sourceMappingURL=approval-resolution.js.map

package/dist/approval-resolution.js.map

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

package/dist/approval-resumes.d.ts

@@ -0,0 +1,102 @@
+import type { AttemptFs } from './start-attempts';
+/**
+ * A PERSON'S ANSWER REACHES EXACTLY ONE RUN.
+ *
+ * When an owner denies, revokes or lets an approval lapse, the pursuit may
+ * carry on — but only once somebody says so, and only once. The next explicit
+ * Start picks the answer up, tells its model precisely what was refused, and
+ * plans around it. Every Start after that is an ordinary Start.
+ *
+ * WHY IT NEEDS ITS OWN RECORD. The approval row looks identical before and
+ * after: `denied` at nine o'clock is `denied` at midnight, and nothing on the
+ * server says whether anybody has acted on it. Without a durable local mark, a
+ * denial would be handed to every run for the rest of the goal's life — the
+ * model told again and again about a decision it has already planned around,
+ * and a pursuit that can never leave the state of having just been refused.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * EXCLUSIVE CREATE, AND NOTHING ELSE
+ *
+ * The same argument `StartAttempts` makes. No read, no "does it exist", no
+ * compare-and-swap of our own: the operating system hands the file to exactly
+ * one caller and the loser finds out from the filesystem rather than from a
+ * stale read it took a moment earlier. Two Starts racing for one answer is
+ * exactly the shape that goes wrong, and an in-process guard would not survive
+ * two daemons — or one daemon and a person at a terminal.
+ *
+ * THERE IS NO RELEASE, AND NO TAKEOVER. A claim is a historical fact: this
+ * answer was given to that run. If the run then died before doing anything with
+ * it, the pursuit is no worse off than a run that died for any other reason —
+ * the next Start is an ordinary Start, and the goal still knows what it knows.
+ * A takeover path would mean an answer could be handed out twice, which is the
+ * one thing this file exists to prevent.
+ */
+export declare const APPROVAL_RESUMES_SCHEMA = 1;
+export interface ApprovalResume {
+    /** The approval whose answer this run was given. */
+    approvalId: string;
+    /** The Start that claimed it. Present before a run exists; see below. */
+    requestId: string;
+    /** ISO, from the claiming process's own clock. */
+    claimedAt: string;
+}
+export type ResumeClaim = {
+    readonly ok: true;
+    readonly resume: ApprovalResume;
+}
+/** Somebody already has it. Not an error — an answer. */
+ | {
+    readonly ok: false;
+    readonly because: string;
+};
+/**
+ * WHAT THE CLAIM IS KEYED BY, AND WHY IT IS THE START AND NOT THE RUN.
+ *
+ * Claimed at the Start boundary, before a run exists, because that is where the
+ * race is: two Starts arrive, and only one may carry the answer. Keying on the
+ * run would mean claiming after the thing the claim is supposed to gate.
+ *
+ * The cost is that a Start which claims and then fails to produce a run has
+ * spent the answer. That is the safe direction — an answer delivered zero times
+ * leaves a goal exactly as informed as it was, while an answer delivered twice
+ * puts a machine in a loop being told the same no.
+ */
+export declare class ApprovalResumes {
+    private readonly stateDir;
+    private readonly fs;
+    private readonly deps;
+    constructor(stateDir: string, fs: AttemptFs, deps?: {
+        now?: () => number;
+    });
+    private get dir();
+    private path;
+    /**
+     * Take this answer, if nobody has.
+     *
+     * The whole mechanism is `createExclusive`. Everything else here is bookkeeping
+     * about what to write in the file that proves it.
+     */
+    claim(approvalId: string, requestId: string): Promise<ResumeClaim>;
+    /** What was claimed for this approval, or null. Unreadable is NOT null — it throws. */
+    claimOf(approvalId: string): Promise<ApprovalResume | null>;
+    /**
+     * Which of these answers have already been given out.
+     *
+     * Takes the ids to ask about rather than listing the directory, because the
+     * gate already knows which approvals exist for the pursuit and a directory
+     * read would be a second, slower answer to a question it has.
+     *
+     * AN UNREADABLE CLAIM IS NOT AN ABSENT ONE. A file held for a moment by
+     * something else — which on Windows is ordinary — would otherwise read as
+     * "not consumed", and the answer would be handed out a second time. So this
+     * reports the trouble and lets the caller hold.
+     */
+    consumed(approvalIds: readonly string[]): Promise<{
+        ok: true;
+        consumed: Set<string>;
+    } | {
+        ok: false;
+        because: string;
+    }>;
+}
+//# sourceMappingURL=approval-resumes.d.ts.map

package/dist/approval-resumes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-resumes.d.ts","sourceRoot":"","sources":["../src/approval-resumes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;CACnB;AAOD,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAAE;AACxD,yDAAyD;GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAExB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAFJ,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,SAAS,EACb,IAAI,GAAE;QAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;KAAO;IAGpD,OAAO,KAAK,GAAG,GAEd;IAED,OAAO,CAAC,IAAI;IAIZ;;;;;OAKG;IACG,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAyBxE,uFAAuF;IACjF,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAMjE;;;;;;;;;;;OAWG;IACG,QAAQ,CACZ,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,OAAO,CAAC;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAoBjF"}

package/dist/approval-resumes.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalResumes = exports.APPROVAL_RESUMES_SCHEMA = void 0;
+/**
+ * A PERSON'S ANSWER REACHES EXACTLY ONE RUN.
+ *
+ * When an owner denies, revokes or lets an approval lapse, the pursuit may
+ * carry on — but only once somebody says so, and only once. The next explicit
+ * Start picks the answer up, tells its model precisely what was refused, and
+ * plans around it. Every Start after that is an ordinary Start.
+ *
+ * WHY IT NEEDS ITS OWN RECORD. The approval row looks identical before and
+ * after: `denied` at nine o'clock is `denied` at midnight, and nothing on the
+ * server says whether anybody has acted on it. Without a durable local mark, a
+ * denial would be handed to every run for the rest of the goal's life — the
+ * model told again and again about a decision it has already planned around,
+ * and a pursuit that can never leave the state of having just been refused.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * EXCLUSIVE CREATE, AND NOTHING ELSE
+ *
+ * The same argument `StartAttempts` makes. No read, no "does it exist", no
+ * compare-and-swap of our own: the operating system hands the file to exactly
+ * one caller and the loser finds out from the filesystem rather than from a
+ * stale read it took a moment earlier. Two Starts racing for one answer is
+ * exactly the shape that goes wrong, and an in-process guard would not survive
+ * two daemons — or one daemon and a person at a terminal.
+ *
+ * THERE IS NO RELEASE, AND NO TAKEOVER. A claim is a historical fact: this
+ * answer was given to that run. If the run then died before doing anything with
+ * it, the pursuit is no worse off than a run that died for any other reason —
+ * the next Start is an ordinary Start, and the goal still knows what it knows.
+ * A takeover path would mean an answer could be handed out twice, which is the
+ * one thing this file exists to prevent.
+ */
+exports.APPROVAL_RESUMES_SCHEMA = 1;
+/**
+ * WHAT THE CLAIM IS KEYED BY, AND WHY IT IS THE START AND NOT THE RUN.
+ *
+ * Claimed at the Start boundary, before a run exists, because that is where the
+ * race is: two Starts arrive, and only one may carry the answer. Keying on the
+ * run would mean claiming after the thing the claim is supposed to gate.
+ *
+ * The cost is that a Start which claims and then fails to produce a run has
+ * spent the answer. That is the safe direction — an answer delivered zero times
+ * leaves a goal exactly as informed as it was, while an answer delivered twice
+ * puts a machine in a loop being told the same no.
+ */
+class ApprovalResumes {
+    stateDir;
+    fs;
+    deps;
+    constructor(stateDir, fs, deps = {}) {
+        this.stateDir = stateDir;
+        this.fs = fs;
+        this.deps = deps;
+    }
+    get dir() {
+        return `${this.stateDir}/approval-resumes`;
+    }
+    path(approvalId) {
+        return `${this.dir}/${approvalId}.json`;
+    }
+    /**
+     * Take this answer, if nobody has.
+     *
+     * The whole mechanism is `createExclusive`. Everything else here is bookkeeping
+     * about what to write in the file that proves it.
+     */
+    async claim(approvalId, requestId) {
+        if (approvalId.length === 0)
+            return { ok: false, because: 'no approval was named' };
+        // Path safety, not validation theatre: the id becomes a filename, and an id
+        // carrying a separator would write outside the directory this owns.
+        if (/[^A-Za-z0-9_-]/.test(approvalId)) {
+            return { ok: false, because: `${approvalId} is not a usable approval id` };
+        }
+        const resume = {
+            approvalId,
+            requestId,
+            claimedAt: new Date(this.deps.now?.() ?? Date.now()).toISOString(),
+        };
+        const body = { schema: exports.APPROVAL_RESUMES_SCHEMA, resume };
+        await this.fs.mkdir(this.dir);
+        try {
+            await this.fs.createExclusive(this.path(approvalId), JSON.stringify(body, null, 2) + '\n');
+        }
+        catch (e) {
+            if (e.code === 'EEXIST') {
+                return { ok: false, because: `this answer has already been given to a run` };
+            }
+            throw e;
+        }
+        return { ok: true, resume };
+    }
+    /** What was claimed for this approval, or null. Unreadable is NOT null — it throws. */
+    async claimOf(approvalId) {
+        const text = await this.fs.readFile(this.path(approvalId));
+        if (text === null)
+            return null;
+        return readResume(text);
+    }
+    /**
+     * Which of these answers have already been given out.
+     *
+     * Takes the ids to ask about rather than listing the directory, because the
+     * gate already knows which approvals exist for the pursuit and a directory
+     * read would be a second, slower answer to a question it has.
+     *
+     * AN UNREADABLE CLAIM IS NOT AN ABSENT ONE. A file held for a moment by
+     * something else — which on Windows is ordinary — would otherwise read as
+     * "not consumed", and the answer would be handed out a second time. So this
+     * reports the trouble and lets the caller hold.
+     */
+    async consumed(approvalIds) {
+        const consumed = new Set();
+        for (const id of approvalIds) {
+            let text;
+            try {
+                text = await this.fs.readFile(this.path(id));
+            }
+            catch (e) {
+                return { ok: false, because: `a resume claim could not be read (${e.message})` };
+            }
+            if (text === null)
+                continue;
+            if (readResume(text) === null) {
+                // Present and unreadable. Counted as consumed, which is the safe
+                // direction: the alternative hands the same answer out again.
+                consumed.add(id);
+                continue;
+            }
+            consumed.add(id);
+        }
+        return { ok: true, consumed };
+    }
+}
+exports.ApprovalResumes = ApprovalResumes;
+function readResume(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const file = parsed;
+    if (typeof file !== 'object' || file === null)
+        return null;
+    if (file.schema !== exports.APPROVAL_RESUMES_SCHEMA)
+        return null;
+    const r = file.resume;
+    if (typeof r !== 'object' || r === null)
+        return null;
+    if (typeof r['approvalId'] !== 'string' || r['approvalId'] === '')
+        return null;
+    if (typeof r['requestId'] !== 'string')
+        return null;
+    if (typeof r['claimedAt'] !== 'string')
+        return null;
+    return {
+        approvalId: r['approvalId'],
+        requestId: r['requestId'],
+        claimedAt: r['claimedAt'],
+    };
+}
+//# sourceMappingURL=approval-resumes.js.map

package/dist/approval-resumes.js.map

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