looply-cli 0.0.0-stage → 0.3.0

package/dist/loop-safety-observer.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vectorFor = vectorFor;
+exports.observationFor = observationFor;
+const core_1 = require("@looply/core");
+const core_2 = require("@looply/core");
+/**
+ * The achievement facts, read off the queue.
+ *
+ * `done` is the only state that means an item was actually finished — the
+ * others are all "not yet" of one kind or another, and `workLeft` is the
+ * repository's own reading of what a set of them amounts to.
+ */
+function vectorFor(goalId, goalVersion, pursuit, passingGates = []) {
+    const done = pursuit.items.filter((i) => i.state === 'done').map((i) => i.id);
+    const outcome = (0, core_2.workLeft)(pursuit.items);
+    return {
+        goalId,
+        goalVersion,
+        verifiedItemIds: done,
+        /**
+         * How many are still workable. `none` and `finished` and `stalled` all mean
+         * nothing more will happen without a person, so they are zero — three words
+         * for the same number here, and the distinction between them is somebody
+         * else's decision.
+         */
+        workRemaining: outcome === 'working' ? pursuit.items.filter(isUnfinished).length : 0,
+        provenCriteria: [],
+        /**
+         * ⚠️ SORTED AND DE-DUPLICATED, so the fingerprint is about WHICH gates
+         * passed and not about the order a runner happened to report them in.
+         */
+        passingGates: [...new Set(passingGates)].sort(),
+        planRevision: pursuit.planRevision,
+    };
+}
+/** The states that are "not finished yet" rather than "finished" or "given up". */
+function isUnfinished(item) {
+    return item.state === 'ready' || item.state === 'draft' || item.state === 'verifying';
+}
+/**
+ * One observation, or null when this attempt is not the model's to answer for.
+ *
+ * Null is the common case in a quiet daemon and is not a failure: a tick that
+ * held, an approval nobody has answered, a recovery carrying one authority
+ * forward. None of those is an attempt that achieved nothing — they are attempts
+ * that never happened.
+ */
+function observationFor(facts) {
+    if (!(0, core_1.countsTowardSafety)(facts.excluded))
+        return null;
+    return {
+        goalId: facts.goalId,
+        goalVersion: facts.goalVersion,
+        ordinal: facts.ordinal,
+        outcome: facts.outcome,
+        progressFingerprint: (0, core_1.progressFingerprint)(vectorFor(facts.goalId, facts.goalVersion, facts.pursuit, 
+        /**
+         * ⚠️ THE HIGH-WATER MARK, NOT THIS ROUND'S SET. See `gatesEverPassed`:
+         * the raw set lets one flaky step change the fingerprint every round,
+         * which makes three identical fingerprints impossible and switches all
+         * four detectors off for a pursuit that is genuinely stuck.
+         *
+         * The union only ever grows, so a step passing for the FIRST time is
+         * progress and a step flapping is not.
+         */
+        [...(facts.gatesEverPassed ?? []), ...(facts.passingGates ?? [])])),
+        treeFingerprint: facts.treeFingerprint,
+        failureSignature: facts.failureSignature,
+        actionFingerprint: facts.actionFingerprint,
+        // TRACE. Carried so a person can find the run; excluded from every digest.
+        runId: facts.runId,
+        observedAt: facts.at,
+    };
+}
+//# sourceMappingURL=loop-safety-observer.js.map

package/dist/loop-safety-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-safety-observer.js","sourceRoot":"","sources":["../src/loop-safety-observer.ts"],"names":[],"mappings":";;AA2EA,8BA2BC;AAwED,wCA+BC;AA7MD,uCAOsB;AACtB,uCAAmD;AA4DnD;;;;;;GAMG;AACH,SAAgB,SAAS,CACvB,MAAc,EACd,WAAmB,EACnB,OAAqB,EACrB,eAAkC,EAAE;IAEpC,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9E,MAAM,OAAO,GAAG,IAAA,eAAQ,EAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACxC,OAAO;QACL,MAAM;QACN,WAAW;QACX,eAAe,EAAE,IAAI;QACrB;;;;;WAKG;QACH,aAAa,EAAE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACpF,cAAc,EAAE,EAAE;QAClB;;;WAGG;QACH,YAAY,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAAE;QAC/C,YAAY,EAAE,OAAO,CAAC,YAAY;KACnC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,SAAS,YAAY,CAAC,IAAU;IAC9B,OAAO,IAAI,CAAC,KAAK,KAAK,OAAO,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,IAAI,IAAI,CAAC,KAAK,KAAK,WAAW,CAAC;AACxF,CAAC;AA2DD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,KAAmB;IAChD,IAAI,CAAC,IAAA,yBAAkB,EAAC,KAAK,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,mBAAmB,EAAE,IAAA,0BAAmB,EACtC,SAAS,CACP,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,OAAO;QACb;;;;;;;;WAQG;QACH,CAAC,GAAG,CAAC,KAAK,CAAC,eAAe,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,CAClE,CACF;QACD,eAAe,EAAE,KAAK,CAAC,eAAe;QACtC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;QAC1C,2EAA2E;QAC3E,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,UAAU,EAAE,KAAK,CAAC,EAAE;KACrB,CAAC;AACJ,CAAC"}

package/dist/loop-safety-store.d.ts

@@ -0,0 +1,339 @@
+import { type LoopSafetyVerdict, type SafetyHoldKind, type SafetyObservation } from '@looply/core';
+import type { LedgerFs } from './ledger-store';
+import type { AttemptFs } from './start-attempts';
+/**
+ * WHAT AUTONOMY HAS ACHIEVED, WRITTEN DOWN SO A RESTART CANNOT FORGET IT.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * THE GAP THIS FILLS
+ *
+ * Nothing in this repository recorded what a Start ACHIEVED. `finishStart`
+ * closes an ordinal with no outcome payload at all — the receipts prove a Start
+ * was spent, the launch records prove a child began, and the refusal marks say
+ * why one did not. None of them says whether the work moved the Goal, so no
+ * detector could have existed before this file.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHY IT IS NOT IN `control.json`
+ *
+ * 🔴 A DIRECT `looply run` ERASES CONTROL STATE. `consumeControlOnStart` is true
+ * for a hand-typed run, so the first thing such a run does is consume a person's
+ * pause. A safety hold stored there would be cleared as a SIDE EFFECT of typing
+ * the command the hold exists to prevent — which is not a hold at all.
+ *
+ * So this is its own file, written by the same temp-then-rename contract every
+ * other store here uses, and the override that clears an incident is an
+ * exclusive create rather than a field somebody can rewrite.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * BOUNDED, BECAUSE A DURABLE HISTORY THAT GROWS IS A DEFECT WITH A DELAY
+ *
+ * `MAX_SAFETY_OBSERVATIONS` is the whole window; the widest detector looks at
+ * four. A file that grew for every attempt would arrive months later on
+ * somebody else's machine, and by then nobody would know why.
+ */
+export type SafetyStoreState = 'ok' | 'unreadable';
+/**
+ * A safety hold, once derived, is a fact about this machine.
+ *
+ * ⚠️ IT HAS NO `expiresAt` AND NO `clear()`. A hold must not disappear because
+ * the daemon restarted, because time passed, or because a model asked nicely —
+ * only a person's explicit Start ends one, and that is recorded rather than
+ * erased so the audit survives.
+ */
+export interface LoopSafetyIncident {
+    readonly id: string;
+    readonly goalId: string;
+    readonly goalVersion: number;
+    readonly kind: SafetyHoldKind;
+    readonly because: string;
+    readonly evidence: readonly string[];
+    /** ISO. TRACE — a person reads it; nothing decides on it. */
+    readonly triggeredAt: string;
+    /** The Start that spent this incident's one retry, if one has. */
+    readonly overriddenByStartId?: string;
+}
+export declare class LoopSafetyStore {
+    private readonly stateDir;
+    /**
+     * ⚠️ `readDir` IS OPTIONAL, so every existing fake still satisfies this.
+     * A store that cannot list the ordinal claims simply falls back to deriving
+     * the next attempt number from the observations, which is what it did
+     * before — weaker, and never wrong in a direction that loses a hold.
+     */
+    private readonly fs;
+    private readonly now;
+    private readonly migrate?;
+    /** Distinguishes two writes from ONE process; the pid distinguishes processes. */
+    private static writes;
+    private observations;
+    private incidents;
+    private state;
+    private opened;
+    /**
+     * ⚠️ `migrate` RUNS BEFORE ANY READ, AND ITS REFUSAL LEAVES THE STORE
+     * UNREADABLE — which is a REFUSAL TO START, not a silent pass.
+     *
+     * The history's home moved out of the repository (see `rails-home.ts`). During
+     * a move, "I could not read the old history" and "there is no old history"
+     * look the same, and this store must never confuse them: an empty history
+     * discharges every hold it holds. A `repeated_failure` hold raised an hour ago
+     * would vanish, the run it was stopping would start, and nothing would say why.
+     *
+     * Omitted, there is no migration and nothing changes.
+     */
+    constructor(stateDir: string, 
+    /**
+     * ⚠️ `readDir` IS OPTIONAL, so every existing fake still satisfies this.
+     * A store that cannot list the ordinal claims simply falls back to deriving
+     * the next attempt number from the observations, which is what it did
+     * before — weaker, and never wrong in a direction that loses a hold.
+     */
+    fs: LedgerFs & Pick<AttemptFs, 'createExclusive'> & {
+        readDir?(path: string): Promise<string[]>;
+    }, now?: () => number, migrate?: (() => Promise<{
+        ok: boolean;
+        because?: string;
+    }>) | undefined);
+    private get path();
+    /**
+     * The append-only history of attempts.
+     *
+     * 🔴 A SEPARATE FILE FROM THE INCIDENTS, AND APPEND-ONLY, BECAUSE A REWRITE
+     * LOSES A CONCURRENT WRITER'S WORK. Two writers for one goal on one machine is
+     * ordinary — the run recording what it achieved, and the Start gate spending a
+     * retry — and a whole-document rewrite meant whichever loaded first clobbered
+     * the other. For the spent retry that was survivable (the marker file is the
+     * authority). For an OBSERVATION it was not: a shorter history holds LATER, so
+     * the machine keeps working, which is the direction that costs a person money.
+     *
+     * The shape is `ledger-store.ts`'s, deliberately: events appended as JSONL,
+     * never rewritten, with the small mutable thing kept as a projection beside
+     * it. ⚠️ NOT `command-receipts.ts` — that one rewrites its whole document too,
+     * and an earlier draft of this file's own handoff cited it as the append-only
+     * precedent. It is not one.
+     *
+     * NEVER COMPACT THIS FILE. `ledger-store` says the same of its own events and
+     * for the same reason: a compaction is a rewrite, and a concurrent append
+     * during one is exactly the loss this change exists to prevent.
+     *
+     * ⚠️ THE COST THIS TRADE BUYS, STATED PLAINLY RATHER THAN LEFT TO BE FOUND.
+     * The whole file is read and parsed on every observation, because the verdict
+     * must be a fact about the machine rather than about one process. So the read
+     * grows with the machine's LIFETIME, not with its current workload: one record
+     * per attempt, forever, re-parsed each time.
+     *
+     * That is affordable at the scale this runs at — attempts are minutes apart
+     * and bounded by the very brake this file feeds — and it is the honest
+     * successor to the limit it replaced, not the absence of one. If a machine
+     * ever accumulates enough attempts for this to matter, the answer is a second
+     * ledger file rolled by date with the old one left in place, NOT a compaction
+     * of this one.
+     */
+    private get eventsPath();
+    /** Where an override's exclusive-create claim lives. One file per incident. */
+    /**
+     * Where incidents are written now: APPEND-ONLY, one per line.
+     *
+     * 🔴 `persist()` REWROTE THE WHOLE DOCUMENT from an `open()`-time snapshot,
+     * and Phase 1 turned that into a hold-erasing race. Moving this file to the
+     * project state directory is what lets a hold raised in one workspace be seen
+     * in another — and the same change put two concurrent writers on it. Two runs
+     * raising holds for two different pursuits each wrote a document without the
+     * other's incident, so one brake vanished. Unlike an override, nothing
+     * recovers it.
+     *
+     * Observations were made append-only long ago for exactly this reason.
+     * Incidents simply never were, because until Phase 1 there could not be two
+     * writers.
+     */
+    private get incidentsPath();
+    /** A short unique token for an incident id. Filename-safe by construction. */
+    private incidentToken;
+    private overridePath;
+    /** Read what is on disk. Never throws: an unreadable file is a state, not a crash. */
+    open(): Promise<SafetyStoreState>;
+    status(): SafetyStoreState;
+    /**
+     * The active incident for a pursuit, or null.
+     *
+     * ⚠️ AN UNREADABLE FILE ANSWERS `null`, AND THAT IS DELIBERATE — but it is
+     * NOT the same as failing open. The caller (`autonomy-tick`) treats an
+     * unreadable store as a hold in its own right, because a machine that cannot
+     * read its safety history must not spend a night on the assumption that it is
+     * empty. Deciding that here would hide it inside a getter.
+     */
+    /**
+     * Whether this store could read its history.
+     *
+     * 🔴 EXPOSED BECAUSE THE RULE ABOVE HAD A SECOND CALLER THAT DID NOT KNOW IT.
+     * `activeIncident` answers null on an unreadable file and says, correctly,
+     * that deciding there "would hide it inside a getter" — but that only works
+     * while every caller applies the rule. `autonomy-tick` did; the coordinator's
+     * `holdsFor` did not, and returned NO HOLDS for an unreadable history, which
+     * `decideSchedule` reads as "nothing is held" and answers with `start`.
+     *
+     * `open()` already returns this; a store that has been opened elsewhere had
+     * no way to be asked again.
+     */
+    readable(): boolean;
+    activeIncident(goalId: string, goalVersion: number): LoopSafetyIncident | null;
+    /** Every incident ever derived for this pursuit, newest last. History, not state. */
+    history(goalId: string): readonly LoopSafetyIncident[];
+    observationsFor(goalId: string): readonly SafetyObservation[];
+    /**
+     * The number to give the next attempt for this pursuit.
+     *
+     * ⚠️ NOT `observationsFor(...).length + 1`, WHICH IS WHAT THIS REPLACED. The
+     * history is bounded at `MAX_SAFETY_OBSERVATIONS`, so a count SATURATES: past
+     * sixteen attempts every one of them is numbered seventeen, and the evidence
+     * a person reads to understand why their machine stopped becomes three
+     * identical lines. No detector reads the ordinal, so nothing went wrong — it
+     * was only unreadable, which is the kind of defect a test suite never has an
+     * opinion about.
+     *
+     * Counting on from the LAST one survives trimming, because trimming keeps the
+     * newest. It restarts at one for a pursuit with no history, which is correct:
+     * a person who has never seen this Goal run should be shown attempt one.
+     */
+    nextOrdinalFor(goalId: string): number;
+    /**
+     * The largest attempt number anybody has already claimed for this goal, or 0.
+     *
+     * ⚠️ CLAIMS, NOT OBSERVATIONS. See `mintOrdinal`. An unreadable directory
+     * answers 0, which makes the caller fall back to the observation-derived
+     * start — the same answer it had before, rather than a refusal.
+     */
+    private highestClaim;
+    /** Where an ordinal's exclusive-create claim lives. One file per attempt. */
+    private ordinalPath;
+    /**
+     * TAKE THE NEXT ATTEMPT NUMBER, EXCLUSIVELY.
+     *
+     * 🔴 `nextOrdinalFor` IS A READ, AND TWO RUNS READ THE SAME ANSWER.
+     *
+     * It derives the next number from the last observation on disk. That was
+     * sound while one run owned one checkout. With N workspaces two runs on one
+     * goal start within the same second, both read "the last attempt was 3", and
+     * both record attempt 4 — so the evidence a person is shown to explain why
+     * their machine stopped contains two different attempt fours and no five.
+     * `MAX_SAME_FAILURE_REPEATS` still fires correctly, because no detector reads
+     * the ordinal; what breaks is the only part of a hold a person can act on.
+     *
+     * ⚠️ THE SAME PRIMITIVE THE OVERRIDE MARKER USES, three files away: the
+     * filesystem arbitrates, never a read-then-write, because the two claimants
+     * may be two processes. On EEXIST the candidate simply advances — losing a
+     * race means somebody else has that number, which is exactly the information
+     * needed to pick the next one.
+     *
+     * ⚠️ GAPS ARE FINE, DUPLICATES ARE NOT. A run that mints 4 and then crashes
+     * burns 4, and the next attempt is 5. Nothing counts ordinals — the history's
+     * length is what detectors read — so a gap costs a person nothing, while a
+     * duplicate costs them the ability to tell two attempts apart.
+     */
+    mintOrdinal(goalId: string): Promise<number>;
+    /**
+     * Record what one attempt achieved, and say whether that makes it unsafe to
+     * continue.
+     *
+     * The verdict is computed from what is now on disk rather than from the
+     * caller's belief, so a caller that forgets to persist cannot produce a
+     * verdict about a history that does not exist.
+     */
+    observe(o: SafetyObservation): Promise<LoopSafetyVerdict>;
+    /**
+     * Write down that autonomy has stopped, and why.
+     *
+     * Idempotent on the pursuit: a second derivation while one is already active
+     * returns the existing incident rather than stacking. Two holds for one
+     * stuck condition would need two overrides to clear, and a person would have
+     * to press the button twice for reasons nobody could explain.
+     */
+    raise(input: {
+        goalId: string;
+        goalVersion: number;
+        kind: SafetyHoldKind;
+        because: string;
+        evidence: readonly string[];
+    }): Promise<LoopSafetyIncident | null>;
+    /**
+     * A PERSON SPENDS AN INCIDENT'S ONE RETRY.
+     *
+     * 🔴 EXCLUSIVE CREATE, AND NOTHING ELSE. Two Starts arriving together must not
+     * both believe they may proceed, and the filesystem is what arbitrates —
+     * never a read-then-write, and never an in-memory flag, because the two Starts
+     * may be two processes. The same Start asking twice gets the same answer, so
+     * a dropped response cannot cost a person their retry.
+     *
+     * ⚠️ ONE RETRY, NOT "SAFETY OFF". The incident is marked as spent rather than
+     * deleted, and the observation history is left exactly where it is. If the
+     * authorised Run also achieves nothing, the detectors see the whole history
+     * and raise a NEW incident — which is the difference between a person saying
+     * "try once more" and a person disabling a brake.
+     */
+    override(incidentId: string, startId: string): Promise<{
+        ok: true;
+        incident: LoopSafetyIncident;
+    } | {
+        ok: false;
+        because: string;
+    }>;
+    /**
+     * Read the attempt history from the append-only ledger.
+     *
+     * Bounded IN MEMORY rather than on disk: the file is never rewritten, so the
+     * only place a bound can be applied without a rewrite is here. `carried` is
+     * whatever an older build left in the document, and goes first because it is
+     * older than anything in the ledger.
+     *
+     * 🔴 A BAD LINE IS SKIPPED, NOT FATAL — and that is the opposite of how this
+     * class treats a bad INCIDENTS document, deliberately. A torn final line is
+     * what a crash mid-append leaves, and it costs one observation, which is the
+     * bounded loss this design already accepts. Refusing to read the history over
+     * it would report NO active incident and so discharge every hold on the
+     * machine, which is the one direction that must never fail open. The
+     * incidents document still fails closed; it is what holds are made of.
+     */
+    private loadObservations;
+    /**
+     * Mark every incident whose retry has already been taken.
+     *
+     * 🔴 THE MARKER FILE IS THE AUTHORITY; THE FIELD IS A CACHE. `persist()`
+     * rewrites the whole document, so a writer that loaded before another
+     * writer's write clobbers it — and the daemon spending a retry while a run
+     * records what it achieved is not an exotic interleaving, it is what happens
+     * every time somebody presses Start as a run ends. The field really is lost
+     * there; it is measured in `loop-safety-race.spec.ts`.
+     *
+     * What cannot be lost is `loop-safety-overrides/<id>`, because it is written
+     * with an exclusive create and never rewritten. So the document is believed
+     * about WHAT was raised, and the marker files about WHICH retries are spent.
+     * Reading them here keeps `activeIncident` synchronous for its callers.
+     *
+     * Bounded by the incident count rather than by anything a person can grow: a
+     * pursuit has one active incident at a time, and only unspent ones are asked
+     * about.
+     */
+    /**
+     * Fold the append-only incident log over whatever the legacy document held.
+     *
+     * A malformed line is SKIPPED rather than fatal: an append can be torn by a
+     * crash mid-write, and discarding every hold on the strength of one truncated
+     * last line would be the fail-open this whole file exists to prevent.
+     */
+    private loadIncidents;
+    private foldInSpentRetries;
+    private readOverride;
+    private persist;
+}
+/**
+ * The real filesystem, in the shape this store needs.
+ *
+ * `createExclusive` is the whole argument for a separate factory: it is the one
+ * operation that must be atomic against another PROCESS, and it is spelled with
+ * the `wx` flag rather than a read-then-write for exactly that reason.
+ */
+export declare const nodeSafetyFs: LedgerFs & Pick<AttemptFs, 'createExclusive'> & {
+    readDir(path: string): Promise<string[]>;
+};
+//# sourceMappingURL=loop-safety-store.d.ts.map

package/dist/loop-safety-store.d.ts.map

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