looply-cli 0.0.0-stage → 0.2.0

package/dist/project-index-store.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectIndexStore = exports.MAX_SNAPSHOTS = void 0;
+const core_1 = require("@looply/core");
+/**
+ * How many snapshots to keep.
+ *
+ * Small on purpose: a snapshot is worth keeping only while somebody might
+ * still be on that revision, and a rebuild is cheap. The alternative — an
+ * unbounded directory of derived files — is the defect that arrives months
+ * later on somebody else's machine, which this codebase has already met once.
+ */
+exports.MAX_SNAPSHOTS = 4;
+class ProjectIndexStore {
+    stateDir;
+    fs;
+    state = 'ok';
+    constructor(stateDir, fs) {
+        this.stateDir = stateDir;
+        this.fs = fs;
+    }
+    pathFor(treeSha) {
+        return `${this.stateDir}/project-index-${treeSha}.json`;
+    }
+    status() {
+        return this.state;
+    }
+    /**
+     * The snapshot for a tree, or null.
+     *
+     * 🔴 REFUSES A SNAPSHOT THAT DOES NOT DESCRIBE THE TREE ASKED FOR. The file
+     * name says which revision it is, and so does the content; if they disagree,
+     * something copied a file or a write was interrupted, and the honest answer
+     * is "I do not have one" rather than a plausible index of the wrong revision.
+     * A stale index is worse than no index, because a reader cannot tell.
+     */
+    async load(treeSha, 
+    /**
+     * 🔴 THE PACKAGE SET THE CALLER WILL BUILD WITH, AND WITHOUT IT THIS CACHE
+     * IS KEYED ON LESS THAN THE SNAPSHOT DEPENDS ON.
+     *
+     * Found by an adversarial review during Phase 13, and it is a fourth class
+     * of staleness none of the checks below can see. A snapshot is a function
+     * of (tree, packages) — `run-cmd.ts` builds it with
+     * `workspacePackages(config)`, derived from `config.scope.free`, which is
+     * read from a WORKING-TREE config file that no tree sha covers. That value
+     * reaches the snapshot twice: every file’s `packageName`, and the signed
+     * `packages` array.
+     *
+     * So a person adding a workspace to their config, without committing and
+     * without any code changing, got the previous package set back for ever
+     * under a matching key — and `factsFromIndex` then wrote "package X lives
+     * at Y" from it. No version bump is even conceptually available for that
+     * class: nothing about the CODE changed.
+     *
+     * ⚠️ OPTIONAL, SO EVERY EXISTING CALLER KEEPS WORKING — but a caller that
+     * omits it is asking to be handed a snapshot built under a package set
+     * nobody compared. The two production callers both pass it.
+     */
+    expectedPackages) {
+        let text;
+        try {
+            text = await this.fs.readFile(this.pathFor(treeSha));
+        }
+        catch {
+            this.state = 'unreadable';
+            return null;
+        }
+        if (text === null)
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            // A torn write. The repository can rebuild it; nothing is lost but time.
+            return null;
+        }
+        if (!isSnapshot(parsed))
+            return null;
+        if (parsed.schema !== core_1.PROJECT_INDEX_SCHEMA)
+            return null;
+        /**
+         * 🔴 AND THE EXTRACTOR VERSION, WHICH IS NOT THE SCHEMA. A snapshot written
+         * by older extraction code describes the repository the way that code used
+         * to — on the correct revision, in the correct shape, and wrongly. The tree
+         * sha cannot see it and neither can the schema, which changes only when the
+         * FILE SHAPE does.
+         */
+        if (parsed.extractor !== core_1.INDEX_EXTRACTOR_VERSION)
+            return null;
+        // The content must agree with the name it was filed under.
+        if (parsed.treeSha !== treeSha)
+            return null;
+        /**
+         * And with the package set it would be rebuilt under. Compared as a sorted
+         * join rather than element-wise because both sides are already sorted by
+         * construction (`buildProjectIndex` sorts, and so does this) — so a
+         * disagreement here is a real difference in membership, never in order.
+         */
+        if (expectedPackages !== undefined) {
+            const want = [...expectedPackages].sort().join(String.fromCharCode(0));
+            const have = [...parsed.packages].sort().join(String.fromCharCode(0));
+            if (want !== have)
+                return null;
+        }
+        return parsed;
+    }
+    /**
+     * Write a snapshot for its own tree.
+     *
+     * Temp-then-rename, so a reader never sees half a file — the same contract
+     * every other durable write in this repository uses, and the reason `load`
+     * can treat unparseable JSON as merely absent rather than as corruption to
+     * reason about.
+     */
+    async save(snapshot) {
+        await this.fs.mkdir(this.stateDir);
+        const target = this.pathFor(snapshot.treeSha);
+        const tmp = `${target}.${process.pid}.tmp`;
+        await this.fs.writeFile(tmp, `${JSON.stringify(snapshot, null, 2)}\n`);
+        await this.fs.rename(tmp, target);
+    }
+}
+exports.ProjectIndexStore = ProjectIndexStore;
+function isSnapshot(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    return (typeof o['schema'] === 'number' &&
+        // Absent on a snapshot written before the version existed, which is
+        // exactly the kind that must not be reused.
+        typeof o['extractor'] === 'number' &&
+        typeof o['treeSha'] === 'string' &&
+        Array.isArray(o['files']) &&
+        Array.isArray(o['symbols']) &&
+        Array.isArray(o['imports']) &&
+        Array.isArray(o['packages']));
+}
+//# sourceMappingURL=project-index-store.js.map

package/dist/project-index-store.js.map

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

package/dist/project-memory-store.d.ts

@@ -0,0 +1,127 @@
+import { type MemoryKind, type ProjectMemoryRecord } from '@looply/core';
+import type { LedgerFs } from './ledger-store';
+/**
+ * How many records of one kind, for one pursuit, the reader keeps.
+ *
+ * 🔴 PER BUCKET, NOT GLOBAL, AND PHASE 9 IS WHY. Its safety history used one
+ * global window across every goal on the machine, so a busy pursuit evicted a
+ * quiet one's history before it reached the threshold that would have stopped
+ * it — the brake switched itself off on the busiest machines, silently. A
+ * global bound here would do the same to memory: one active goal would erase
+ * another's decisions.
+ */
+export declare const MAX_PER_BUCKET = 32;
+/**
+ * Caps on the free-text fields.
+ *
+ * Deliberately small. A `content` long enough to hold a stack trace is a
+ * `content` long enough to hold a secret, and the point of memory is a claim a
+ * person could have written on a card.
+ */
+export declare const MAX_SUBJECT_CHARS = 200;
+export declare const MAX_CONTENT_CHARS = 1000;
+export declare const MAX_NOTE_CHARS = 200;
+export declare const MAX_REFS = 16;
+export type MemoryStoreState = 'ok' | 'unreadable';
+export type RememberResult = {
+    readonly ok: true;
+    readonly record: ProjectMemoryRecord;
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+/** What a caller supplies. `id` and `recordedAt` are the store's to mint. */
+export type MemoryDraft = Omit<ProjectMemoryRecord, 'id' | 'recordedAt'> & {
+    /** Only meaningful on an attempt; see `semanticKey`. */
+    readonly distinct?: string;
+};
+export interface MemoryQuery {
+    readonly kind?: MemoryKind;
+    readonly goalId?: string;
+    readonly subject?: string;
+    readonly path?: string;
+    /** Hard ceiling on what comes back. Defaults to `MAX_PER_BUCKET`. */
+    readonly limit?: number;
+}
+/** A record as held in memory: what was written, plus its identity. */
+type Held = ProjectMemoryRecord & {
+    readonly key: string;
+};
+export declare class ProjectMemoryStore {
+    private readonly stateDir;
+    /**
+     * 🔴 THE ISOLATION KEY, FIXED AT CONSTRUCTION. A record whose scope names a
+     * different project is not filtered out of a query — it is never loaded.
+     * Isolation that depends on every caller remembering to pass a filter is
+     * isolation that holds until the first caller forgets.
+     */
+    private readonly projectKey;
+    private readonly fs;
+    private readonly now;
+    private records;
+    private state;
+    private opened;
+    private minted;
+    constructor(stateDir: string, 
+    /**
+     * 🔴 THE ISOLATION KEY, FIXED AT CONSTRUCTION. A record whose scope names a
+     * different project is not filtered out of a query — it is never loaded.
+     * Isolation that depends on every caller remembering to pass a filter is
+     * isolation that holds until the first caller forgets.
+     */
+    projectKey: string, fs: LedgerFs, now?: () => number);
+    private get path();
+    /** Read what is on disk. Never throws: an unreadable file is a state. */
+    open(): Promise<MemoryStoreState>;
+    /**
+     * Parse the ledger, skipping anything unreadable.
+     *
+     * ⚠️ A BAD LINE IS SKIPPED, NOT FATAL. A torn final line is what a crash
+     * leaves, and it costs one record. Refusing to read the whole file over it
+     * would discard every decision and every failed approach the project has
+     * accumulated — which is a far worse outcome than losing the last one.
+     *
+     * A line whose `schema` is unknown is skipped for a different reason: this
+     * repository's convention is that a reader REFUSES TO GUESS rather than
+     * silently misreading a shape it does not know.
+     */
+    private parse;
+    status(): MemoryStoreState;
+    /**
+     * Write something down, if its author is entitled to assert it.
+     *
+     * `writtenByModel` is supplied by the RUNTIME, never by the record. See
+     * `admitMemory` for why that separation is the whole fence.
+     */
+    remember(draft: MemoryDraft, writtenByModel: boolean): Promise<RememberResult>;
+    /** Trim the free-text fields to their caps. See the header on why. */
+    private bound;
+    /** Every record ever written for this project, newest last. History, not truth. */
+    history(): readonly Held[];
+    /** The ids a later record has explicitly replaced. */
+    private supersededIds;
+    /**
+     * What memory says about the present.
+     *
+     * 🔴 BOUNDED PER BUCKET AND CURRENCY-FILTERED. A caller asking "what do you
+     * know" must not receive the project's entire history: an unbounded answer is
+     * one nobody reads and a context nobody can budget.
+     */
+    current(currentTreeSha: string | null, query?: MemoryQuery): readonly Held[];
+}
+/**
+ * The per-working-copy isolation key.
+ *
+ * 🔴 NOT THE SERVER'S `projectId`. An unpaired machine stamps events
+ * `projectId: 'local'` — a shared literal — so two unrelated repositories on one
+ * machine would collide under it. This is derived from the absolute path of the
+ * working copy, which is always available, needs no pairing, and differs
+ * between any two checkouts.
+ *
+ * ⚠️ IT FAILS CLOSED ON A MOVE. Relocating a repository changes its key, so its
+ * memory stops being found. That is the safe direction: the alternative is
+ * memory being adopted by whatever now occupies the old path.
+ */
+export declare function projectKeyFor(absoluteRepoPath: string, sha256: (s: string) => string): string;
+export {};
+//# sourceMappingURL=project-memory-store.d.ts.map

package/dist/project-memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-memory-store.d.ts","sourceRoot":"","sources":["../src/project-memory-store.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,UAAU,EACf,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AA6C/C;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,YAAY,CAAC;AAEnD,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,EAAE,IAAI,GAAG,YAAY,CAAC,GAAG;IACzE,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAeD,uEAAuE;AACvE,KAAK,IAAI,GAAG,mBAAmB,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,qBAAa,kBAAkB;IAO3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAftB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAK;gBAGA,QAAQ,EAAE,MAAM;IACjC;;;;;OAKG;IACc,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,QAAQ,EACZ,GAAG,GAAE,MAAM,MAAyB;IAGvD,OAAO,KAAK,IAAI,GAEf;IAED,yEAAyE;IACnE,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAcvC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,KAAK;IAmBb,MAAM,IAAI,gBAAgB;IAI1B;;;;;OAKG;IACG,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IA2CpF,sEAAsE;IACtE,OAAO,CAAC,KAAK;IAab,mFAAmF;IACnF,OAAO,IAAI,SAAS,IAAI,EAAE;IAI1B,sDAAsD;IACtD,OAAO,CAAC,aAAa;IAMrB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,GAAE,WAAgB,GAAG,SAAS,IAAI,EAAE;CAiCjF;AAsBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAO7F"}

package/dist/project-memory-store.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMemoryStore = exports.MAX_REFS = exports.MAX_NOTE_CHARS = exports.MAX_CONTENT_CHARS = exports.MAX_SUBJECT_CHARS = exports.MAX_PER_BUCKET = void 0;
+exports.projectKeyFor = projectKeyFor;
+const trusted_git_1 = require("./trusted-git");
+const core_1 = require("@looply/core");
+/**
+ * DURABLE PROJECT MEMORY — `.looply/state/project-memory.jsonl`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * APPEND-ONLY, AND NOT BY PREFERENCE
+ *
+ * Two runs can learn the same thing at once, and a daemon can be writing while
+ * a run is. The repository has exactly two durable-write idioms — append-only
+ * JSONL with a rebuilt projection, and create-once `O_EXCL` one file per fact —
+ * and a third was invented once, in Phase 9: a whole-document rewrite, which
+ * lost a concurrent writer's record and had to be replaced by this same shape.
+ * That lesson is two weeks old. This starts where it ended.
+ *
+ * The file is NEVER rewritten. Not trimmed, not compacted, not rotated. A
+ * compaction is a rewrite and a rewrite is the bug, so the bound lives on what
+ * is READ rather than on what is kept — see `MAX_PER_BUCKET`.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 EVERY RECORD IS LED BY A NEWLINE
+ *
+ * A crash part-way through an append leaves a fragment with no trailing
+ * newline. If the next record were merely terminated by one it would
+ * concatenate onto that fragment and BOTH would be unreadable — one torn write
+ * costing two records. Leading each record means a fragment always ends up
+ * alone on its line and is skipped by itself. The blank line this leaves in the
+ * ordinary case is skipped by the same rule, and it needs no read-before-append,
+ * so it stays correct against a concurrent writer.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT CANNOT REACH THIS FILE
+ *
+ * There is no general redaction utility in this repository, and that is
+ * deliberate: the house policy is structural exclusion, because a blocklist
+ * fails open the day somebody adds a field it does not know. So this store has
+ * NO ACCESS PATH to command output, prompts, environments or logs — it accepts
+ * a subject, a claim, and identifiers. The length caps below are not tidiness;
+ * they are what stops a caller pasting a log into `content` and calling it a
+ * memory.
+ */
+/** The one file. Never rewritten — see the header. */
+const MEMORY_FILE = 'project-memory.jsonl';
+/**
+ * How many records of one kind, for one pursuit, the reader keeps.
+ *
+ * 🔴 PER BUCKET, NOT GLOBAL, AND PHASE 9 IS WHY. Its safety history used one
+ * global window across every goal on the machine, so a busy pursuit evicted a
+ * quiet one's history before it reached the threshold that would have stopped
+ * it — the brake switched itself off on the busiest machines, silently. A
+ * global bound here would do the same to memory: one active goal would erase
+ * another's decisions.
+ */
+exports.MAX_PER_BUCKET = 32;
+/**
+ * Caps on the free-text fields.
+ *
+ * Deliberately small. A `content` long enough to hold a stack trace is a
+ * `content` long enough to hold a secret, and the point of memory is a claim a
+ * person could have written on a card.
+ */
+exports.MAX_SUBJECT_CHARS = 200;
+exports.MAX_CONTENT_CHARS = 1000;
+exports.MAX_NOTE_CHARS = 200;
+exports.MAX_REFS = 16;
+class ProjectMemoryStore {
+    stateDir;
+    projectKey;
+    fs;
+    now;
+    records = [];
+    state = 'ok';
+    opened = false;
+    minted = 0;
+    constructor(stateDir, 
+    /**
+     * 🔴 THE ISOLATION KEY, FIXED AT CONSTRUCTION. A record whose scope names a
+     * different project is not filtered out of a query — it is never loaded.
+     * Isolation that depends on every caller remembering to pass a filter is
+     * isolation that holds until the first caller forgets.
+     */
+    projectKey, fs, now = () => Date.now()) {
+        this.stateDir = stateDir;
+        this.projectKey = projectKey;
+        this.fs = fs;
+        this.now = now;
+    }
+    get path() {
+        return `${this.stateDir}/${MEMORY_FILE}`;
+    }
+    /** Read what is on disk. Never throws: an unreadable file is a state. */
+    async open() {
+        this.opened = true;
+        let text;
+        try {
+            text = await this.fs.readFile(this.path);
+        }
+        catch {
+            this.state = 'unreadable';
+            return this.state;
+        }
+        this.records = text === null ? [] : this.parse(text);
+        this.state = 'ok';
+        return this.state;
+    }
+    /**
+     * Parse the ledger, skipping anything unreadable.
+     *
+     * ⚠️ A BAD LINE IS SKIPPED, NOT FATAL. A torn final line is what a crash
+     * leaves, and it costs one record. Refusing to read the whole file over it
+     * would discard every decision and every failed approach the project has
+     * accumulated — which is a far worse outcome than losing the last one.
+     *
+     * A line whose `schema` is unknown is skipped for a different reason: this
+     * repository's convention is that a reader REFUSES TO GUESS rather than
+     * silently misreading a shape it does not know.
+     */
+    parse(text) {
+        const out = [];
+        for (const line of text.split('\n')) {
+            if (line.trim() === '')
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isStoredLine(parsed))
+                continue;
+            if (parsed.schema !== core_1.PROJECT_MEMORY_SCHEMA)
+                continue;
+            // Never loaded, not merely filtered. See the constructor.
+            if (parsed.scope.projectKey !== this.projectKey)
+                continue;
+            out.push(parsed);
+        }
+        return out;
+    }
+    status() {
+        return this.state;
+    }
+    /**
+     * Write something down, if its author is entitled to assert it.
+     *
+     * `writtenByModel` is supplied by the RUNTIME, never by the record. See
+     * `admitMemory` for why that separation is the whole fence.
+     */
+    async remember(draft, writtenByModel) {
+        if (!this.opened)
+            throw new Error('ProjectMemoryStore.remember before open()');
+        if (this.state === 'unreadable') {
+            // Appending to a file we could not read would be writing into the dark:
+            // the duplicate check below is derived from what was loaded, so every
+            // repeat observation would land again and grow the file without bound.
+            return { ok: false, because: 'the memory ledger could not be read' };
+        }
+        if (draft.scope.projectKey !== this.projectKey) {
+            return { ok: false, because: 'that memory belongs to another project' };
+        }
+        const bounded = this.bound(draft);
+        const admission = (0, core_1.admitMemory)(bounded, writtenByModel);
+        if (!admission.ok)
+            return { ok: false, because: admission.because };
+        /**
+         * The same claim observed again is ONE memory. A newer observation of an
+         * unchanged claim still gets appended — the revision it was seen at is what
+         * makes it useful — but only when something a reader would act on differs,
+         * so a run that re-observes an unchanged world adds nothing.
+         */
+        const key = (0, core_1.semanticKey)(bounded);
+        const existing = this.records.find((r) => r.key === key);
+        if (existing !== undefined && existing.revision?.treeSha === draft.revision?.treeSha) {
+            return { ok: true, record: existing };
+        }
+        this.minted += 1;
+        const record = {
+            ...bounded,
+            id: `mem_${this.now().toString(36)}_${this.minted.toString(36)}`,
+            recordedAt: new Date(this.now()).toISOString(),
+        };
+        await this.fs.mkdir(this.stateDir);
+        await this.fs.appendFile(this.path, `\n${JSON.stringify({ schema: core_1.PROJECT_MEMORY_SCHEMA, key, ...record })}\n`);
+        this.records.push({ ...record, key });
+        return { ok: true, record };
+    }
+    /** Trim the free-text fields to their caps. See the header on why. */
+    bound(d) {
+        return {
+            ...d,
+            subject: d.subject.slice(0, exports.MAX_SUBJECT_CHARS),
+            content: d.content.slice(0, exports.MAX_CONTENT_CHARS),
+            provenance: {
+                ...d.provenance,
+                refs: d.provenance.refs.slice(0, exports.MAX_REFS),
+                ...(d.provenance.note === undefined ? {} : { note: d.provenance.note.slice(0, exports.MAX_NOTE_CHARS) }),
+            },
+        };
+    }
+    /** Every record ever written for this project, newest last. History, not truth. */
+    history() {
+        return this.records;
+    }
+    /** The ids a later record has explicitly replaced. */
+    supersededIds() {
+        const out = new Set();
+        for (const r of this.records)
+            if (r.supersedes !== undefined)
+                out.add(r.supersedes);
+        return out;
+    }
+    /**
+     * What memory says about the present.
+     *
+     * 🔴 BOUNDED PER BUCKET AND CURRENCY-FILTERED. A caller asking "what do you
+     * know" must not receive the project's entire history: an unbounded answer is
+     * one nobody reads and a context nobody can budget.
+     */
+    current(currentTreeSha, query = {}) {
+        const superseded = this.supersededIds();
+        const limit = Math.max(0, Math.min(query.limit ?? exports.MAX_PER_BUCKET, exports.MAX_PER_BUCKET));
+        const matching = this.records.filter((r) => {
+            // A withdrawal exists only to retire another record. It is never
+            // itself shown — it is not a claim, it is the act of dropping one.
+            if (r.withdrawn === true)
+                return false;
+            if (!(0, core_1.currencyOf)(r, { currentTreeSha, supersededIds: superseded }).current)
+                return false;
+            if (query.kind !== undefined && r.kind !== query.kind)
+                return false;
+            if (query.goalId !== undefined && r.scope.goalId !== query.goalId)
+                return false;
+            if (query.subject !== undefined && r.subject !== query.subject)
+                return false;
+            if (query.path !== undefined && r.scope.path !== query.path)
+                return false;
+            return true;
+        });
+        /**
+         * Newest wins for one semantic claim: a fact re-observed at a newer tree
+         * supersedes its own older observation without anybody writing a
+         * supersession, which is what stops a stale duplicate outliving its update.
+         */
+        // Newest wins for one semantic claim: a fact re-observed at a newer tree
+        // supersedes its own older observation without anybody writing a
+        // supersession, which stops a stale duplicate outliving its update.
+        //
+        // The key is the one stored at WRITE time, so two attempts differing only
+        // by the run they happened in stay two — see `StoredLine.key`.
+        const newestByClaim = new Map();
+        for (const r of matching)
+            newestByClaim.set(r.key, r);
+        const collapsed = [...newestByClaim.values()];
+        return collapsed.slice(Math.max(0, collapsed.length - limit));
+    }
+}
+exports.ProjectMemoryStore = ProjectMemoryStore;
+function isStoredLine(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    const scope = o['scope'];
+    return (typeof o['schema'] === 'number' &&
+        typeof o['id'] === 'string' &&
+        typeof o['kind'] === 'string' &&
+        typeof o['source'] === 'string' &&
+        typeof o['subject'] === 'string' &&
+        typeof o['content'] === 'string' &&
+        typeof o['recordedAt'] === 'string' &&
+        typeof o['provenance'] === 'object' &&
+        o['provenance'] !== null &&
+        typeof scope === 'object' &&
+        scope !== null &&
+        typeof scope['projectKey'] === 'string');
+}
+/**
+ * The per-working-copy isolation key.
+ *
+ * 🔴 NOT THE SERVER'S `projectId`. An unpaired machine stamps events
+ * `projectId: 'local'` — a shared literal — so two unrelated repositories on one
+ * machine would collide under it. This is derived from the absolute path of the
+ * working copy, which is always available, needs no pairing, and differs
+ * between any two checkouts.
+ *
+ * ⚠️ IT FAILS CLOSED ON A MOVE. Relocating a repository changes its key, so its
+ * memory stops being found. That is the safe direction: the alternative is
+ * memory being adopted by whatever now occupies the old path.
+ */
+function projectKeyFor(absoluteRepoPath, sha256) {
+    // 🔴 THE REPOSITORY, NOT THE DIRECTORY — same reason as `repoPathHash`. A run
+    // in a linked worktree was reading an EMPTY project memory and writing its
+    // own, so everything the project had learned stopped being carried in.
+    // Unchanged for an ordinary checkout, which resolves to itself.
+    const path = (0, trusted_git_1.repoIdentityPath)(absoluteRepoPath);
+    return `pk_${sha256(path.replace(/\\/g, '/').toLowerCase()).slice(0, 32)}`;
+}
+//# sourceMappingURL=project-memory-store.js.map

package/dist/project-memory-store.js.map

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

package/dist/proposal-store.d.ts

@@ -0,0 +1,14 @@
+import { type ProposalRecord } from '@looply/core';
+import type { LedgerFs } from './ledger-store';
+import { AppendOnlyStore } from './record-store';
+/**
+ * THE PROPOSAL RECORDS ON DISK — `.looply/state/proposals.jsonl`.
+ *
+ * Append-only (see `record-store.ts`), keyed by the record id — the QUESTION
+ * (goal, version, tree, prompt digest) — so the same question asked again is
+ * answered from here and the transport is not called twice for it.
+ */
+export declare class ProposalStore extends AppendOnlyStore<ProposalRecord> {
+    constructor(stateDir: string, fs: LedgerFs);
+}
+//# sourceMappingURL=proposal-store.d.ts.map

package/dist/proposal-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal-store.d.ts","sourceRoot":"","sources":["../src/proposal-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,qBAAa,aAAc,SAAQ,eAAe,CAAC,cAAc,CAAC;gBACpD,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ;CAG3C"}

package/dist/proposal-store.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalStore = void 0;
+const core_1 = require("@looply/core");
+const record_store_1 = require("./record-store");
+/**
+ * THE PROPOSAL RECORDS ON DISK — `.looply/state/proposals.jsonl`.
+ *
+ * Append-only (see `record-store.ts`), keyed by the record id — the QUESTION
+ * (goal, version, tree, prompt digest) — so the same question asked again is
+ * answered from here and the transport is not called twice for it.
+ */
+class ProposalStore extends record_store_1.AppendOnlyStore {
+    constructor(stateDir, fs) {
+        super(stateDir, 'proposals.jsonl', core_1.isProposalRecord, fs);
+    }
+}
+exports.ProposalStore = ProposalStore;
+//# sourceMappingURL=proposal-store.js.map

package/dist/proposal-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal-store.js","sourceRoot":"","sources":["../src/proposal-store.ts"],"names":[],"mappings":";;;AAAA,uCAAqE;AAErE,iDAAiD;AAEjD;;;;;;GAMG;AACH,MAAa,aAAc,SAAQ,8BAA+B;IAChE,YAAY,QAAgB,EAAE,EAAY;QACxC,KAAK,CAAC,QAAQ,EAAE,iBAAiB,EAAE,uBAAgB,EAAE,EAAE,CAAC,CAAC;IAC3D,CAAC;CACF;AAJD,sCAIC"}