looply-cli 0.0.0-stage → 0.3.0

package/dist/autonomy-authority.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAutonomyAuthority = checkAutonomyAuthority;
+const autonomy_store_1 = require("./autonomy-store");
+const start_attempts_1 = require("./start-attempts");
+async function checkAutonomyAuthority(deps, requestId, attempt) {
+    const autonomy = new autonomy_store_1.AutonomyStore(deps.stateDir, deps.fs);
+    const read = await autonomy.read();
+    if (!read.ok) {
+        // A record of what this machine may spend that cannot be read is not
+        // permission to spend it.
+        return { ok: false, because: `this machine could not read its own grants (${read.because})` };
+    }
+    // DERIVE, never parse. Walk what was actually adopted and actually reserved,
+    // and see whether any of it produces the id in hand.
+    let found = null;
+    for (const grant of read.progress) {
+        const spend = await autonomy.spendOf(grant.controllerId, grant.maxStarts);
+        if (!spend.ok) {
+            // A budget that cannot be read or cannot be trusted is not a budget this
+            // execution may lean on. Reported rather than skipped: skipping would let
+            // a damaged grant be quietly stepped over on the way to a sound one.
+            return {
+                ok: false,
+                because: `the spend of grant ${grant.controllerId} cannot be trusted (${spend.because})`,
+            };
+        }
+        for (const ordinal of spend.spend.reserved) {
+            if ((0, autonomy_store_1.autonomyStartId)(grant.controllerId, ordinal) === requestId) {
+                found = { controllerId: grant.controllerId, ordinal };
+                break;
+            }
+        }
+        if (found)
+            break;
+    }
+    if (found === null) {
+        return {
+            ok: false,
+            because: 'no grant on this machine reserved a Start by that name',
+        };
+    }
+    // THE TRY ITSELF. A reservation says a Start was bought; a launch says the
+    // daemon spent one of three tries at executing it. Without one, this process
+    // was not asked for by anything.
+    const attempts = new start_attempts_1.StartAttempts(deps.stateDir, deps.fs, undefined, {
+        pid: () => deps.pid,
+        host: () => deps.host,
+    });
+    const spent = await attempts.launches(requestId);
+    if (!spent.ok) {
+        return { ok: false, because: `the tries at that Start cannot be trusted (${spent.because})` };
+    }
+    const mine = spent.launches.find((l) => l.launch.attempt === attempt);
+    if (mine === undefined) {
+        return { ok: false, because: `no daemon launched attempt ${attempt} of that Start` };
+    }
+    // AND IF THE DAEMON HAS SAID WHAT IT SPAWNED, IT MUST BE THIS.
+    const spawn = mine.spawn;
+    if (spawn !== null) {
+        if (!spawn.spawned) {
+            return {
+                ok: false,
+                because: `the daemon recorded that attempt ${attempt} produced no child`,
+            };
+        }
+        if (spawn.host !== deps.host) {
+            return {
+                ok: false,
+                because: `attempt ${attempt} was spawned on ${spawn.host}, not here`,
+            };
+        }
+        if (spawn.pid !== undefined && spawn.pid !== deps.pid) {
+            return {
+                ok: false,
+                because: `attempt ${attempt} was spawned as process ${spawn.pid}, not ${deps.pid}`,
+            };
+        }
+    }
+    return { ok: true, controllerId: found.controllerId, ordinal: found.ordinal };
+}
+//# sourceMappingURL=autonomy-authority.js.map

package/dist/autonomy-authority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-authority.js","sourceRoot":"","sources":["../src/autonomy-authority.ts"],"names":[],"mappings":";;AA2EA,wDAmFC;AA9JD,qDAAmF;AACnF,qDAAiE;AA0E1D,KAAK,UAAU,sBAAsB,CAC1C,IAAmB,EACnB,SAAiB,EACjB,OAAe;IAEf,MAAM,QAAQ,GAAG,IAAI,8BAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3D,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;QACb,qEAAqE;QACrE,0BAA0B;QAC1B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,+CAA+C,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IAChG,CAAC;IAED,6EAA6E;IAC7E,qDAAqD;IACrD,IAAI,KAAK,GAAqD,IAAI,CAAC;IACnE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QAC1E,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;YACd,yEAAyE;YACzE,0EAA0E;YAC1E,qEAAqE;YACrE,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,OAAO,EAAE,sBAAsB,KAAK,CAAC,YAAY,uBAAuB,KAAK,CAAC,OAAO,GAAG;aACzF,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC3C,IAAI,IAAA,gCAAe,EAAC,KAAK,CAAC,YAAY,EAAE,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;gBAC/D,KAAK,GAAG,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;gBACtD,MAAM;YACR,CAAC;QACH,CAAC;QACD,IAAI,KAAK;YAAE,MAAM;IACnB,CAAC;IAED,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO;YACL,EAAE,EAAE,KAAK;YACT,OAAO,EAAE,wDAAwD;SAClE,CAAC;IACJ,CAAC;IAED,2EAA2E;IAC3E,6EAA6E;IAC7E,iCAAiC;IACjC,MAAM,QAAQ,GAAG,IAAI,8BAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE;QACpE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG;QACnB,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI;KACtB,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACjD,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;QACd,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,8CAA8C,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;IAChG,CAAC;IACD,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;IACtE,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,8BAA8B,OAAO,gBAAgB,EAAE,CAAC;IACvF,CAAC;IAED,+DAA+D;IAC/D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACzB,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,OAAO,EAAE,oCAAoC,OAAO,oBAAoB;aACzE,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YAC7B,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,OAAO,EAAE,WAAW,OAAO,mBAAmB,KAAK,CAAC,IAAI,YAAY;aACrE,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YACtD,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,OAAO,EAAE,WAAW,OAAO,2BAA2B,KAAK,CAAC,GAAG,SAAS,IAAI,CAAC,GAAG,EAAE;aACnF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;AAChF,CAAC"}

package/dist/autonomy-controller.d.ts

@@ -0,0 +1,321 @@
+import { type ApprovalGate, type GoalAutonomyState, type RunRefusalCode } from '@looply/core';
+import type { AttemptProgress } from './start-attempts';
+import type { Publication } from './completion';
+/**
+ * WHAT A CONTROLLER DOES NEXT, AND NOTHING ELSE.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * A REDUCER, NOT A LOOP
+ *
+ * This file is pure. It is handed a snapshot of facts that are already durable
+ * somewhere else and it returns ONE action. It reads no file, spawns nothing,
+ * calls no model, and has no idea what a queue or a plan revision is.
+ *
+ * That is the whole design. A controller that looped would have to decide, mid
+ * flight, whether the world it read at the top of the loop still holds — and
+ * every one of those decisions is a place where two daemons disagree. A
+ * reducer that returns after one transition re-reads everything next tick, so
+ * the answer is always about the world as it is now.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT IT IS NOT ALLOWED TO KNOW
+ *
+ * It never asks whether the goal is met, what work is left, which plan revision
+ * is current, or what the evaluator thinks. All of that lives inside one
+ * bounded Start, behind the same seam a person's tap goes through, and the
+ * controller's entire relationship with it is: ask for one, and read the
+ * structured answer.
+ *
+ * If this file ever needs to know something about the WORK in order to decide,
+ * that is the signal that the decision belongs inside the Start rather than
+ * here.
+ */
+/** One durable transition, or one reason there is not one. */
+export type ControllerAction = 
+/**
+ * Take the next Start slot. Costs budget, permanently.
+ *
+ * Deliberately NOT followed by executing it in the same tick. Reservation and
+ * execution are separate durable facts, and a crash between them must leave
+ * an ordinal that a later tick resumes rather than one that is lost.
+ */
+{
+    kind: 'reserve-ordinal';
+    ordinal: number;
+}
+/** Ask the bounded Start seam to execute this attempt of this request. */
+ | {
+    kind: 'execute-attempt';
+    ordinal: number;
+    requestId: string;
+    attempt: number;
+    /** Programme mode (M6-7): this Start continues from a decision a person made; the tick reads which. */
+    fromDecision?: true;
+}
+/** The run this ordinal produced has durably ended. Close the ordinal. */
+ | {
+    kind: 'finish-ordinal';
+    ordinal: number;
+    runId: string;
+}
+/** Nothing to do: something is legitimately in progress. */
+ | {
+    kind: 'wait';
+    because: string;
+}
+/**
+ * The pursuit is over, and this is what it came to.
+ *
+ * `state` is the word the server stores; `code` is the machine reason it came
+ * from, kept so that later projection reports what actually happened rather
+ * than re-deriving it from prose.
+ */
+ | {
+    kind: 'terminal';
+    state: GoalAutonomyState;
+    because: string;
+    code?: RunRefusalCode;
+}
+/**
+ * The pursuit is already over locally; tell the server so.
+ *
+ * Its own transition, taken on its own tick. Deriving a terminal state,
+ * writing it locally and reporting it onward in one breath would mean a crash
+ * between the second and the third leaves nothing to retry from — and the
+ * point of writing it locally first is precisely that a restart knows what to
+ * report without re-deriving it.
+ */
+ | {
+    kind: 'project-terminal';
+    state: GoalAutonomyState;
+    because: string;
+}
+/**
+ * The server already knows how this ended. Write that down and stop asking.
+ *
+ * There was no way to record this, and the gap kept a finished pursuit alive
+ * for ever. `projectedAt` — the mark that means "somebody else knows" — was
+ * reachable only by REPORTING an ending. When the server had reached the
+ * ending first, there was nothing to report, so nothing was ever marked, so
+ * the grant stayed in the daemon's live set and took a turn every cadence for
+ * the life of the state directory.
+ *
+ * Observing an ending and proving one are different acts, but they leave the
+ * machine in the same place: the server knows, and this machine has nothing
+ * further to say. So it reuses the same mark rather than inventing a second
+ * one that would have to be kept in step with it.
+ */
+ | {
+    kind: 'accept-server-ending';
+    state: GoalAutonomyState;
+    because: string;
+}
+/**
+ * Cannot act safely. NOT terminal — the world may become readable again.
+ *
+ * Server unreachable, a record that cannot be trusted, a claimant that cannot
+ * be probed. Every one of them means "not now", and none of them means "the
+ * goal is finished".
+ */
+ | {
+    kind: 'hold';
+    because: string;
+};
+/**
+ * What the server currently says about this grant, or why it could not say.
+ *
+ * `unreachable` is its own arm rather than a null, because the difference
+ * between "the server says this grant is cancelled" and "I could not ask" is
+ * the difference between stopping for ever and waiting a few seconds.
+ */
+export type Reconciliation = {
+    kind: 'active';
+    maxStarts: number;
+} | {
+    kind: 'ended';
+    state: GoalAutonomyState;
+    because: string;
+} | {
+    kind: 'mismatch';
+    because: string;
+} | {
+    kind: 'unreachable';
+    because: string;
+};
+/** The facts a decision is made from. Every one of them is durable elsewhere. */
+export interface ControllerFacts {
+    controllerId: string;
+    /** What the machine locally believes the grant has come to. */
+    localState: GoalAutonomyState;
+    /** The absolute end of the grant, as the machine holds it. ISO. */
+    expiresAt: string;
+    /** Ordinals reserved and not yet closed, LOWEST FIRST. */
+    unfinished: readonly number[];
+    /** How many ordinals have been reserved in total. */
+    startsConsumed: number;
+    /** The ceiling the grant was given. */
+    maxStarts: number;
+    /**
+     * What has been tried for the LOWEST unfinished ordinal, and what became of
+     * it. Absent when there is no unfinished ordinal to have progress about.
+     */
+    attempt?: AttemptProgress;
+    /** Whether the run that ordinal produced has durably ended, when there is one. */
+    runEnded?: {
+        ok: true;
+        ended: boolean;
+    } | {
+        ok: false;
+        because: string;
+    };
+    /** What the server says right now. Required before anything is spent. */
+    reconciliation: Reconciliation;
+    /**
+     * A person's pending pause or stop, if one is on disk.
+     *
+     * NOT knowledge about the work — the controller still has none. It is the one
+     * bit that says whether somebody has asked for the machine to hold, and it
+     * gates spending exactly as reconciliation does.
+     *
+     * It exists because obeying a stop inside one run was never enough. The run
+     * ended, the controller bought the next ordinal, and the night carried on:
+     * the person's instruction had stopped one run out of eight rather than the
+     * pursuit. Absent means nothing is pending.
+     */
+    humanHold?: {
+        kind: 'pause' | 'stop';
+        actor?: string;
+    };
+    /** Programme mode, slice 1 (M6-7): an `approved` decision lets the machine continue without another tap. */
+    programme?: boolean;
+    /**
+     * Whether the server already agrees this pursuit is over.
+     *
+     * Absent when nobody has asked. `false` means the machine holds a terminal
+     * state the server has not been told about — which is the one thing a
+     * finished controller still has to do.
+     */
+    serverKnowsItEnded?: boolean;
+    /**
+     * Whether this machine has already written down that the server knows.
+     *
+     * Absent or false means the mark is still owed. Without it the accepting
+     * transition would have no way to stop repeating itself.
+     */
+    endingRecorded?: boolean;
+    /**
+     * The machine's own record of what it has spent is DAMAGED.
+     *
+     * Not "could not be read" — that is weather, and it holds. This is a receipt
+     * whose contents contradict where it is sitting, or a hole where one was
+     * removed. The budget is the receipts, so a budget that cannot be believed
+     * cannot bound anything, and no amount of waiting will make the bytes agree.
+     *
+     * Absent when the record is sound.
+     */
+    recordsDamaged?: string;
+    /**
+     * Whether human authority is outstanding, as the SERVER currently holds it.
+     *
+     * DERIVED ELSEWHERE, AND DELIBERATELY OPAQUE HERE. The producer reads the
+     * rows, applies the clock and decides what they mean; this file is handed the
+     * conclusion and gates spending on it, exactly as it does with
+     * `reconciliation`. It cannot tell an approval from a pause and has no
+     * vocabulary for what was asked — that is the property the whole file is
+     * arranged around.
+     *
+     * ABSENT MEANS NOT ASKED, and that is a real state rather than an oversight:
+     * a controller for a grant with no pursuit to ask about, and every test
+     * written before this existed. `unknown` is the arm for "asked and could not
+     * tell", and it holds.
+     */
+    approvalGate?: ApprovalGate;
+    /**
+     * Whether this machine has decided that repeating is useless, and why.
+     *
+     * DERIVED ELSEWHERE AND DELIBERATELY OPAQUE HERE, exactly like
+     * `approvalGate` above: the producer reads the durable observation history,
+     * applies the detectors and hands down a conclusion. This file cannot tell a
+     * no-progress hold from an oscillation and has no vocabulary for either —
+     * which is what stops a brake from growing into a second planner.
+     *
+     * 🔴 IT IS A MACHINE FACT, NOT A MODEL ONE. Nothing a model says can produce
+     * it, and no threshold behind it is reachable from an action payload or a
+     * project config. A brake the braked thing can release is not a brake.
+     *
+     * ABSENT MEANS NOTHING HAS BEEN OBSERVED — a controller for a pursuit with no
+     * history yet, and every test written before this existed.
+     */
+    loopSafety?: {
+        readonly held: true;
+        readonly because: string;
+    } | {
+        readonly held: false;
+    };
+    /**
+     * THE THIRD KEY (M5-2): whether the lane has published the branch of the
+     * Start that refused. PRESENT ONLY WHEN THE CALLER INTEGRATES FOR ITSELF —
+     * the daemon supplies it behind `machine.integrate` and the lane's own
+     * `run.integration`; every other caller, and every project with either off,
+     * hands nothing and gets today's decision byte for byte.
+     *
+     * Read fresh each cadence like every other fact here: the lane moves between
+     * ticks, and a held grant is re-examined, never remembered.
+     */
+    publication?: Publication;
+    /** Milliseconds since the epoch, from the caller's clock. */
+    now: number;
+    /** The request id for an ordinal. Injected so this file derives no names itself. */
+    requestIdFor: (ordinal: number) => string;
+}
+/**
+ * WHAT A REFUSAL MEANS FOR THE PURSUIT.
+ *
+ * One decision, exhaustive over the code union. The `never` in the default arm
+ * is the point: adding a `RunRefusalCode` without deciding what it means for a
+ * person's grant stops compiling, rather than silently falling through to
+ * "carry on" — which would be the machine deciding, by omission, to spend
+ * somebody's budget on a refusal nobody had thought about.
+ */
+/** The pursuit ends in this state, for this reason. Today's whole answer. */
+export interface RefusalEnd {
+    state: GoalAutonomyState;
+    because: string;
+}
+/**
+ * The answer once the third key is asked for (M5-2): the pursuit ends, or it
+ * is HELD open for the lane (re-examined next cadence, nothing spent), or this
+ * Start closes and the NEXT one is bought — the lane wants the work re-cut from
+ * its moved base, and only a new Start can do that.
+ */
+export type RefusalDecision = RefusalEnd | {
+    readonly hold: string;
+} | {
+    readonly next: string;
+};
+/** What the controller is handed when the caller integrates for itself. */
+export interface ThirdKey {
+    readonly publication: Publication;
+}
+export declare function decideControllerRefusal(code: RunRefusalCode): RefusalEnd;
+export declare function decideControllerRefusal(code: RunRefusalCode, facts: ThirdKey | undefined): RefusalDecision;
+/**
+ * ONE TICK. ONE ACTION.
+ *
+ * The order of the questions is the safety argument:
+ *
+ *   Local terminal truth first, so a machine that already knows the pursuit is
+ *   over stops without asking anybody's permission to stop.
+ *
+ *   Then the clock, which the machine owns a copy of and can check offline.
+ *
+ *   Then whatever is already in progress — because reading progress needs no
+ *   authority, and because acting on a Start that already exists is never
+ *   spending anything new.
+ *
+ *   Only then reconciliation, which gates everything that COSTS: reserving an
+ *   ordinal and executing one. A person can cancel between a reservation and
+ *   its execution, so both are gated, not just the first.
+ */
+export declare function decideAutonomyTick(facts: ControllerFacts): ControllerAction;
+//# sourceMappingURL=autonomy-controller.d.ts.map

package/dist/autonomy-controller.d.ts.map

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