looply-cli 0.0.0-stage → 0.3.0

package/dist/goal-ownership.d.ts

@@ -0,0 +1,416 @@
+import { type Goal, type Item, type RunScope } from '@looply/core';
+import { QueueStore } from './queue-store';
+import type { ItemPatch, QueueWriteResult } from './queue-store';
+import type { LedgerFs } from './ledger-store';
+/**
+ * Who owns which item, and what a run bound to a goal is allowed to see.
+ *
+ * This file exists so that neither the queue store nor the round runner has to
+ * know what a goal is. The store takes patches and knows nothing about why;
+ * the runner asks its queue for work and cannot tell whether that queue is the
+ * whole backlog or one goal's slice of it. Everything that connects the two
+ * ideas is here, in one file, where it can be read in one sitting.
+ */
+/** The three methods a run's queue must offer. Structural on purpose. */
+export interface ScopableQueue {
+    list(): Item[];
+    get(id: string): Item | undefined;
+    update(id: string, expectedVersion: number, patch: ItemPatch): Promise<QueueWriteResult>;
+}
+/**
+ * The same queue, showing only what this run owns.
+ *
+ * `list()` is filtered and NOTHING else is. That asymmetry is the whole design:
+ * `list()` is how work is chosen, so scoping it is what stops two runs picking
+ * the same item — but `get()` and `update()` are how work already in hand is
+ * read back and written, and scoping those would make a run unable to finish an
+ * item whose ownership changed underneath it. A run that cannot write down what
+ * it just did is worse than one that sees an item it will not pick.
+ *
+ * The filter is symmetric: a goal run sees only its own items, and an unbound
+ * run sees only unowned ones. The second half matters as much as the first —
+ * without it, a hand-typed `looply run` would quietly pick up work a goal is in
+ * the middle of.
+ */
+export declare function scopedQueue<Q extends ScopableQueue>(queue: Q, scope: RunScope): ScopableQueue;
+/**
+ * What a run is bound to, once the goal it named has been resolved.
+ *
+ * `retry` and `refused` are separate for the daemon's sake: a start-run left
+ * queued is offered again every few seconds for the whole redelivery window, so
+ * a refusal that retrying cannot fix has to be able to say so. "The server is
+ * unreachable" is worth retrying; "that goal was abandoned" never will be.
+ */
+export type GoalBinding = {
+    kind: 'bound';
+    goal: Goal;
+} | {
+    kind: 'unbound';
+} | {
+    kind: 'retry';
+    reason: string;
+} | {
+    kind: 'refused';
+    reason: string;
+    /**
+     * WHICH refusal, for a machine.
+     *
+     * Assigned by the branch that took it. Without this the only way to tell
+     * "the goal moved on" from "the goal was given up" is to read the
+     * sentence — and a caller reading sentences is the parsing this whole
+     * vocabulary exists to remove.
+     */
+    lapse: AuthorityLapse;
+};
+/** The mirror a run reads its goal from, narrowed to what resolution needs. */
+export interface GoalMirror {
+    get(goalId: string): Goal | null;
+}
+export interface ResolveGoalDeps {
+    goalId?: string | undefined;
+    /** The version the SERVER stamped when the phone tapped Start. */
+    goalVersion?: number | undefined;
+    mirror: GoalMirror;
+    /** The project this working tree belongs to, for the cross-project check. */
+    projectId: string;
+    /**
+     * Re-pull the mirror from the server. Absent when this machine is not paired
+     * at all, which is not a failure — it is a machine that can only ever act on
+     * what it already has.
+     */
+    refresh?: (() => Promise<'ok' | 'unreachable'>) | undefined;
+}
+/**
+ * Resolve the goal a Start named, refreshing the local mirror only if it must.
+ *
+ * The happy path is deliberately OFFLINE. The daemon pulls goals on its own
+ * cadence, so by the time it spawns a run the mirror almost always already
+ * holds the version the phone was looking at — and a run that phoned home
+ * before it could begin would make the server a dependency of doing any work at
+ * all, which is the opposite of what this product is.
+ *
+ * The version is what makes that safe. It is not a freshness heuristic: the
+ * server stamped it at the moment the command was created, so an exact match
+ * proves the mirror holds the very goal the person tapped Start on, whatever
+ * has happened since.
+ */
+export declare function resolveGoalBinding(deps: ResolveGoalDeps): Promise<GoalBinding>;
+/**
+ * What a goal owns, sorted by what this run may do with it.
+ *
+ * The compile decision used to be `the goal owns nothing`, a bare count over
+ * every state and every version. That conflated four different situations — a
+ * goal that has never been planned, one whose plan is finished, one carrying a
+ * previous version's plan, and one a person gave work to by hand — and answered
+ * all of them the same way.
+ */
+export interface GoalWorkSplit {
+    /** This run's own plan: compiled by the compiler for exactly this version. */
+    currentPlan: Item[];
+    /** Adopted by a person. Eligible whatever the goal's wording has become. */
+    manual: Item[];
+    /** A previous version's plan. Owned, durable, and not this run's to work. */
+    olderPlans: Item[];
+    /**
+     * Compiler output whose version was never recorded — Phase 5's own items.
+     * Inert: not manual, not current, and never migrated or given a guess.
+     */
+    unknownPlans: Item[];
+    /** Not compiler output, yet carrying a compiler version. Corruption. */
+    forged: Item[];
+    /**
+     * Compiled for a LATER version than this run is bound to.
+     *
+     * Not merely excluded. Versions only go up, so this is durable evidence
+     * against the authority the run is acting under, and the run refuses rather
+     * than quietly working something else.
+     */
+    newerPlans: Item[];
+}
+export declare function splitGoalWork(items: readonly Item[], scope: RunScope): GoalWorkSplit;
+/**
+ * Has the compiler already produced a plan for THIS version of this goal?
+ *
+ * Counts `current-plan` and nothing else. Not manual work, which a person
+ * provided rather than the compiler planning it; not an earlier plan, whose
+ * counting was the original defect; and not a provenance-unknown legacy item,
+ * because "some compiler once made this" is not evidence that THIS version has
+ * a plan — treating it as such would leave an amended goal unable to compile
+ * for ever, which is the same defect wearing a different hat.
+ *
+ * Existence, not usability: a finished current plan still exists, and that is
+ * what stops a second one being compiled for the same version.
+ */
+export declare function currentCompilerPlanExists(items: readonly Item[], scope: RunScope): boolean;
+/**
+ * How many plans this goal version has had, read back off the queue.
+ *
+ * THE ONLY HOME THAT FAILS CLOSED, and the reason is that it is not a separate
+ * fact at all — it is a property of the rows themselves. queue.json has writers
+ * that do not hold the lease, so a stale one can rename its own snapshot over
+ * the file; but when it does, the revision number and the plan it counts go in
+ * the SAME rename. The next Start then sees the earlier revision and
+ * re-materialises that one, which is a retry. It can never see a later revision
+ * than the work that survives, so a clobber cannot skip a budget forward.
+ *
+ * Counted over the goal's own compiled rows at this VERSION, whatever revision
+ * they belong to — deliberately NOT through `scopedQueue`, which hides earlier
+ * revisions and would therefore forget they ever happened. `releaseOnAbandon`
+ * keeps `closed` rows owned, so the marker each revision leaves behind survives
+ * an abandonment that frees everything still workable.
+ *
+ * Zero means this version has had no plan yet. An absent revision reads as 1,
+ * which is what every plan compiled before revisions existed is.
+ */
+export declare function currentPlanRevision(items: readonly Item[], goalId: string, goalVersion: number): number;
+/**
+ * Why a run did or did not ask the compiler for a plan.
+ *
+ * Named rather than boolean because three of the four answers are things a
+ * person may need told: "there is already a plan for this version" and "there
+ * is work here that can still move" are not the same silence.
+ */
+export type CompileVerdict = {
+    compile: true;
+} | {
+    compile: false;
+    because: 'unbound' | 'contradicted' | 'plan-exists' | 'work-in-progress';
+};
+/**
+ * Should this run compile a plan for the goal version it is bound to?
+ *
+ * THE ONE AUTHORITY. It existed twice before — once in `run-cmd`, once
+ * re-implemented in the exercise that claims to prove `run-cmd` — and the two
+ * had already drifted apart: the copy used `nothing scoped-visible at all`,
+ * which answers CASE 7 (an older plan kept, the person's own work now finished,
+ * no plan for this version) with "do not compile" while the real composition
+ * root compiles. A test written against the copy would have proved the opposite
+ * of the behaviour it was named after and passed. Two predicates for one
+ * question is the defect; this is the fix, and the exercise now calls it.
+ *
+ * The order is the argument:
+ *
+ *   unbound         a run with no goal never compiles — there is no intent to
+ *                   compile FROM.
+ *   contradicted    the queue holds a plan for a LATER version, which is
+ *                   durable evidence this run's authority is stale. `run-cmd`
+ *                   refuses terminally before ever reaching here; this is the
+ *                   second lock, so that removing the first cannot silently
+ *                   turn a contradiction into a fresh plan.
+ *   plan-exists     this version has already had one. EXISTENCE, not progress:
+ *                   a finished or stalled plan still counts, and that is what
+ *                   makes same-version replanning impossible in this phase.
+ *   work-in-progress  something eligible can still move — work a person
+ *                   supplied by hand, or this version's own plan — so get on
+ *                   with it rather than planning around it.
+ *
+ * `eligible` must be the VERSION-AWARE set (a `scopedQueue` listing), never the
+ * raw queue: counting an older plan's items as "work in progress" is how an
+ * amended goal would never get a plan of its own.
+ */
+export declare function decideCompile(split: GoalWorkSplit, eligible: readonly Pick<Item, 'state' | 'attempts'>[], scope: RunScope): CompileVerdict;
+/**
+ * Durable evidence that this run must not act under.
+ *
+ * Returned as the offending items rather than a boolean so the refusal can say
+ * which ones and at what version, which is the only useful thing to tell
+ * somebody whose queue has been rewritten underneath them.
+ */
+export declare function contradictingItems(items: readonly Item[], scope: RunScope): Item[];
+/**
+ * KEY 2 USED TO LIVE HERE, and it asked the wrong question.
+ *
+ * `confirmGoalEvidence` required every delivered item to hold a verifier
+ * evidence entry recorded at the CURRENT head. An adversarial review proved
+ * that can never be true: evidence is written by the verify pass at a head read
+ * BEFORE the work, the round then commits — moving HEAD — and only then marks
+ * the item `done`. Nothing writes evidence in between, so a genuinely delivered
+ * item always answers `moved`, and no goal could ever be confirmed as met.
+ *
+ * The replacement is `goal-execution-evidence.ts`, which asks what the machine
+ * can actually answer: did a real round for THIS revision commit, is that
+ * commit what the repository is standing on now, and did its gate pass every
+ * currently-required step. The evidence cache keeps its original job of feeding
+ * file:line claims to the implementer; it is simply no longer a completion
+ * authority.
+ */
+/**
+ * IS THIS STILL THE AUTHORITY? — decided over a mirror somebody else read.
+ *
+ * PURE, and extracted for the reason `confirmGoalExecutionEvidence` is pure:
+ * production and the tests must run the SAME decision rather than two
+ * descriptions of it. A negative control proved that mattered here — the rule
+ * lived as a closure inside `runLoop` and the end-to-end file had written its
+ * own copy, so breaking the real one changed no test at all.
+ *
+ * Local-first. The caller supplies what the mirror FILE says right now; nothing
+ * here reaches for a server, and a machine whose mirror has not yet learned of
+ * a newer goal may go on working the one it knows. What this refuses is going
+ * on after the newer authority has arrived here.
+ */
+/**
+ * Why authority no longer stands, as a machine reads it.
+ *
+ * Carried alongside the human sentence, and assigned by the branch that knows —
+ * never sniffed out of the sentence afterwards, which would put the prose
+ * parsing back one layer down.
+ */
+export type AuthorityLapse = 'superseded' | 'abandoned' | 'gone' | 'behind' | 'unreadable';
+export declare function stillTheAuthority(fresh: {
+    ok: true;
+    goals: readonly Goal[];
+} | {
+    ok: false;
+    because: string;
+}, goalId: string, boundVersion: number, 
+/**
+ * The wording this run was BOUND to, when the caller still has it.
+ *
+ * ⚠️ OPTIONAL, AND ABSENT MEANS ABSENT. Three of the four places that refuse
+ * a superseded goal hold only one of the two texts — a Start carries an id
+ * and a number, and a queue's contradicting rows carry a version — so they
+ * genuinely cannot answer "which part changed" and are not asked to pretend.
+ * Given nothing, this says exactly what it said before.
+ */
+boundText?: string): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+    lapse: AuthorityLapse;
+    unknown?: boolean;
+};
+export type MaterialiseOutcome = {
+    ok: true;
+    created: number;
+    alreadyThere: number;
+} | {
+    ok: false;
+    problem: string;
+};
+/**
+ * Write a compiled plan into the queue, as one durable batch.
+ *
+ * The choke point for the ownership invariant, and the only reason this is a
+ * function rather than a call to `insertAll` at the call site: EVERY item a
+ * compilation produces must be born owned by the goal it was compiled for, and
+ * this is where that is enforced rather than hoped for.
+ *
+ * The invariant is forced by selection, not chosen. `scopedQueue` filters
+ * symmetrically: an unowned compiled item would be invisible to the very run
+ * that compiled it, and visible to an unbound run that knows nothing about the
+ * goal. So an item arriving here without the right owner is a bug in the caller,
+ * and refusing the WHOLE batch is the only safe answer — a partial plan is a
+ * shape nobody asked for.
+ *
+ * Idempotent through `insertAll`: an id already in the queue is skipped, so a
+ * retry after a crash lands only what is missing, and a retry after a complete
+ * write lands nothing. That works precisely because compiled ids are derived
+ * from the goal, its version and the step, rather than minted per attempt.
+ */
+export declare function materialiseGoalPlan(queue: QueueStore, goalId: string, items: readonly Omit<Item, 'version'>[]): Promise<MaterialiseOutcome>;
+export type AdoptOutcome = {
+    ok: true;
+    adopted: number;
+    alreadyOwned: number;
+} | {
+    ok: false;
+    problem: string;
+};
+/**
+ * Hand a set of items to a goal, all of them or none.
+ *
+ * One durable write, because the alternative — `update` per item — can be
+ * interrupted halfway and leave a goal owning some of what the phone named and
+ * not the rest, with nothing recording which. A caller retrying that has no way
+ * to tell a partial adoption from a fresh one.
+ *
+ * Every refusal names the item. Adoption is a deliberate act performed from a
+ * screen where the person can see the item, so "one of these is wrong" is not a
+ * useful answer.
+ */
+export declare function adoptGoalItems(queue: QueueStore, goalId: string, itemIds: readonly string[]): Promise<AdoptOutcome>;
+export interface ReleaseOutcome {
+    released: number;
+    /** Owned items a run is holding. Left owned on purpose; see `releaseOnAbandon`. */
+    heldByARun: number;
+    /** Finished items. Their goalId is the record of what this goal produced. */
+    keptAsRecord: number;
+}
+/**
+ * Let go of everything a goal owns that can still be worked.
+ *
+ * Takes no item ids, deliberately. The phone that abandons a goal does not know
+ * what that goal came to own — items are adopted over a whole evening, and a
+ * list assembled by a client is a list that is already stale. The instruction is
+ * "let this goal's work go"; the machine that holds the queue decides what that
+ * means, item by item, from {@link releaseOnAbandon}.
+ *
+ * Idempotent: running it twice releases nothing the second time, because there
+ * is nothing left owned that is releasable.
+ */
+export declare function releaseGoalItems(queue: QueueStore, goalId: string): Promise<ReleaseOutcome>;
+/**
+ * Carrying out a `release-goal-items` command on this machine.
+ *
+ * A seam rather than a direct call, so the daemon's command handler can be
+ * tested without a state directory, and so the one hazard below lives in a
+ * single place.
+ */
+export interface GoalReleaser {
+    release(goalId: string, goalVersion: number): Promise<ReleaseOutcome | {
+        busy: string;
+    }>;
+}
+/**
+ * The real one, over the queue on disk.
+ *
+ * Two things here are load-bearing, and both were learned from a race that
+ * reached a state neither command's contract described.
+ *
+ * FIRST, it TAKES the tree rather than merely looking at it. The daemon and the
+ * run are separate processes over one `queue.json`; a check followed by a write
+ * leaves a window in which the run can take the lease and adopt in between, and
+ * the release then completes against a queue that no longer describes reality.
+ * The lease is already an exclusive create — the only mutual exclusion in this
+ * system — so the release holds it for the few milliseconds it writes, exactly
+ * as a run does. A `LeaseHeldError` is the busy answer, and it arrives from the
+ * filesystem rather than from a check that can go stale.
+ *
+ * SECOND, it writes the abandonment into the local goal mirror. Releasing the
+ * items is not enough on its own: a Start bound to G@7 that is still in flight,
+ * or that arrives later on a machine whose mirror is behind and offline, would
+ * resolve against `active` and adopt the very items this just freed — into a
+ * goal nobody is pursuing, with the one-shot release already acked and gone.
+ * The release IS this machine being told the goal was let go, so it remembers.
+ * That is not instant revocation and it does not need the server: a machine
+ * that has not heard still starts, exactly as before. It only refuses once it
+ * has carried the release out itself.
+ */
+export declare function nodeGoalReleaser(stateDir: string, fs: LedgerFs, leases: LeaseGate, cliVersion: string, 
+/** The mirror to record the abandonment in. Absent in tests that do not keep one. */
+goals?: GoalMirrorWriter): GoalReleaser;
+/** What the releaser needs of the lease store: exclusion, not a peek. */
+export interface LeaseGate {
+    acquire(input: {
+        runId: string;
+        branch: string;
+        baseBranch: string;
+        cliVersion: string;
+    }): Promise<{
+        token: string;
+    }>;
+    release(token: string): Promise<unknown>;
+}
+/**
+ * What the releaser needs of the goal mirror.
+ *
+ * Narrow on purpose: the release may mark a goal given up, and may do nothing
+ * else to it. It never invents a goal the mirror has not heard of — and does
+ * not need to, because {@link resolveGoalBinding} can never bind a goal that is
+ * absent from the mirror: it refreshes, and refuses or retries.
+ */
+export interface GoalMirrorWriter {
+    markAbandoned(goalId: string, goalVersion: number): Promise<unknown>;
+}
+//# sourceMappingURL=goal-ownership.d.ts.map

package/dist/goal-ownership.d.ts.map

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