opensquid 0.5.432 → 0.5.447

package/dist/engine-client.js

@@ -1,301 +0,0 @@
-/**
- * Thin JSON-RPC 2.0 client that spawns `loop-engine serve` as a
- * subprocess and talks to it over stdin/stdout.
- *
- * Responsibilities:
- *  - Spawn the engine binary lazily on first call.
- *  - Map outgoing requests to pending promises by `id`.
- *  - Translate JSON-RPC error responses into thrown JS Errors with
- *    `.code` and `.data` attached.
- *  - Survive crashes: if the subprocess exits, the next call respawns.
- *
- * Binary discovery (v0.4 — see src/config.ts resolveEngineBin):
- *   1. `OPENSQUID_ENGINE_BIN` env var — explicit override
- *   2. `<data-root>/config.json` `engine_bin` field — persisted choice
- *   3. Auto-search common dev paths (~/projects/<*>/engine/target/release/
- *      and ~/work/<*>/engine/target/release/)
- *   4. $PATH — system-installed binary
- *   5. Throw with a helpful error message
- *
- * On first successful auto-discovery, the resolved path is written back
- * to config.json so subsequent sessions skip the search. Moving the
- * loop-engine checkout invalidates the cached path; the next start
- * re-discovers automatically.
- *
- * v0.2 keeps the subprocess alive across the MCP session lifetime —
- * a single engine process serves all tool calls until the MCP host
- * disconnects.
- */
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { resolveEngineBin } from "./config.js";
-export class RpcError extends Error {
-    code;
-    data;
-    constructor(message, code, data) {
-        super(message);
-        this.name = "RpcError";
-        this.code = code;
-        this.data = data;
-    }
-}
-export class EngineClient {
-    proc = null;
-    reader = null;
-    pending = new Map();
-    nextId = 1;
-    startupAck = null;
-    /** Lazily spawn the engine subprocess. Idempotent. */
-    async ensureStarted() {
-        if (this.proc)
-            return;
-        if (this.startupAck)
-            return this.startupAck;
-        const bin = await resolveEngineBin();
-        if (!bin) {
-            throw new Error("loop-engine binary not found. Set OPENSQUID_ENGINE_BIN, or run " +
-                "`opensquid engine set-path <path>`, or build the engine at " +
-                "~/projects/loop/engine/target/release/loop-engine");
-        }
-        const proc = spawn(bin, ["serve"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                // Pin the engine to opensquid's storage root so the on-disk
-                // layout is shared across both halves.
-                LOOP_HOME: process.env.LOOP_HOME ?? `${process.env.HOME}/.opensquid`,
-            },
-        });
-        this.proc = proc;
-        this.reader = createInterface({ input: proc.stdout });
-        this.reader.on("line", (line) => this.handleLine(line));
-        proc.stderr.on("data", (chunk) => {
-            // Engine logs go to stderr; mirror them but tag so they're
-            // distinguishable from opensquid's own logs.
-            const text = chunk.toString().trimEnd();
-            if (text)
-                console.error(`[engine] ${text}`);
-        });
-        proc.on("exit", (code) => {
-            const reason = `engine subprocess exited (code=${code ?? "null"})`;
-            console.error(`[opensquid] ${reason}`);
-            this.proc = null;
-            this.reader = null;
-            // #170: clear the cached startup promise so the next call's
-            // `ensureStarted()` actually respawns instead of returning the
-            // stale resolved promise from the previous lifetime. Honors the
-            // "Survive crashes: if the subprocess exits, the next call
-            // respawns" invariant in this file's header docstring.
-            this.startupAck = null;
-            // Reject all in-flight calls so callers can retry.
-            for (const [, pending] of this.pending) {
-                pending.reject(new Error(reason));
-            }
-            this.pending.clear();
-        });
-        proc.on("error", (err) => {
-            console.error(`[opensquid] engine spawn error: ${err.message}`);
-        });
-        // Single ping to confirm the engine is live before we return.
-        this.startupAck = this.call("ping", {})
-            .then(() => undefined)
-            .catch((e) => {
-            throw new Error(`engine failed to start: ${e.message}`);
-        });
-        return this.startupAck;
-    }
-    handleLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return;
-        let msg;
-        try {
-            msg = JSON.parse(trimmed);
-        }
-        catch (e) {
-            console.error(`[opensquid] failed to parse engine line: ${e}`);
-            return;
-        }
-        const pending = this.pending.get(msg.id);
-        if (!pending) {
-            console.error(`[opensquid] response for unknown id=${msg.id}`);
-            return;
-        }
-        this.pending.delete(msg.id);
-        if (msg.error) {
-            pending.reject(new RpcError(msg.error.message, msg.error.code, msg.error.data));
-        }
-        else {
-            pending.resolve(msg.result);
-        }
-    }
-    /**
-     * Send a JSON-RPC request, await the response. Throws `RpcError` on
-     * engine-side errors; throws `Error` on subprocess crashes.
-     */
-    async call(method, params) {
-        if (method !== "ping")
-            await this.ensureStarted();
-        const id = this.nextId++;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, {
-                resolve: (v) => resolve(v),
-                reject,
-            });
-            const req = JSON.stringify({ jsonrpc: "2.0", id, method, params });
-            if (!this.proc) {
-                reject(new Error("engine subprocess not running"));
-                return;
-            }
-            this.proc.stdin.write(req + "\n");
-        });
-    }
-    /** Graceful shutdown — kill the subprocess. */
-    shutdown() {
-        if (this.proc) {
-            this.proc.kill();
-            this.proc = null;
-        }
-    }
-}
-export class OpenSquidEngine {
-    client = new EngineClient();
-    shutdown() {
-        this.client.shutdown();
-    }
-    ping() {
-        return this.client.call("ping", {});
-    }
-    createLesson(args) {
-        return this.client.call("lesson.create", args);
-    }
-    recall(args) {
-        return this.client.call("lesson.recall", args);
-    }
-    promote(args) {
-        return this.client.call("lesson.promote", args);
-    }
-    discard(args) {
-        return this.client.call("lesson.discard", args);
-    }
-    /**
-     * v0.5 / engine v1.3: paginated list across the four non-discarded
-     * status dirs. Order is deterministic (status then id ascending).
-     * Default limit 50, capped at 500. Pass `statuses` to restrict to
-     * specific dirs (e.g. `["pending"]` for the pending-candidates flow).
-     */
-    listLessons(args) {
-        return this.client.call("lesson.list", args);
-    }
-    /**
-     * v0.5 / engine v1.3: record a thumbs-up or thumbs-down on a lesson.
-     * Adds to the lesson's `external_signal_sources`, which feeds the
-     * wedge gate's signal-diversity check. Idempotent on
-     * `source_signal_id` — passing the same signal twice doesn't
-     * double-count. If `source_signal_id` is omitted, the engine mints a
-     * synthetic one (the call still records).
-     */
-    captureFeedback(args) {
-        return this.client.call("lesson.capture_feedback", args);
-    }
-    /**
-     * v0.5 / engine v1.3: point an old lesson at a new replacement.
-     * Old lesson moves to `superseded/`, new lesson is unaffected. The
-     * causal chain is preserved via `superseded_by`. User-authored
-     * lessons are protected unless `force: true`.
-     *
-     * Engine errors:
-     *   -32004 — supersede blocked (cycle detected, self-reference,
-     *            or replacement not found)
-     *   -32001 — user lesson immune (force=true required)
-     *   -32002 — old or new lesson not found
-     */
-    supersedeLesson(args) {
-        return this.client.call("lesson.supersede", args);
-    }
-    createMemory(args) {
-        return this.client.call("memory.create", args);
-    }
-    searchMemory(args) {
-        return this.client.call("memory.search", args);
-    }
-    /**
-     * v0.3.1: fetch a single memory by id with full content + scope.
-     * Throws `RpcError` with code -32002 if no memory with that id
-     * exists (engine returns `DispatchError::NotFound`).
-     */
-    getMemory(args) {
-        return this.client.call("memory.get", args);
-    }
-    /**
-     * v0.5 / engine v1.4: central RAG-style assembly. Returns active
-     * lessons (deterministic-sorted, gate-annotated, applied_count
-     * bumped) + optional memory recall in one shot. This is what a host
-     * like Hermes calls to get "what rules apply right now" instead of
-     * stitching together listLessons + searchMemory.
-     *
-     * Skill/persona/team activation IDs are not threaded through in v0.5
-     * (deferred to a later release per find-simple-solutions). The
-     * active_skills / active_personas / active_teams arrays in the
-     * response ship empty.
-     */
-    assembleManifest(args) {
-        return this.client.call("manifest.assemble", args);
-    }
-    /**
-     * v0.5 / engine v1.3: paginated memory enumeration. Filter-optional
-     * via scope_filter (same wire shape as searchMemory). Default limit
-     * 50, capped at 500. Order is deterministic (id ascending — memory
-     * ids are ULID-shaped so this is roughly chronological).
-     *
-     * Returns frontmatter rows but NOT body — call getMemory(id) for
-     * the full content of any single hit. consumed_by_user_lessons is
-     * the reverse-citation count enforcing the user-immunity invariant
-     * (>0 means a user-authored lesson cites this memory; prune refuses).
-     */
-    listMemories(args) {
-        return this.client.call("memory.list", args);
-    }
-    /**
-     * v0.4: mutate description / content / scope on an existing memory.
-     * Identity, citation counter, derived_from, and origin are always
-     * preserved. Re-embeds on content change; cheap path for
-     * description/scope-only edits. At least one mutable field must
-     * be supplied. Throws `RpcError` -32002 if the id doesn't exist.
-     */
-    updateMemory(args) {
-        return this.client.call("memory.update", args);
-    }
-    /**
-     * v0.4: `forget` — delete a memory. `force = false` (default)
-     * respects user-immunity (returns RpcError -32003 if cited by a
-     * user-authored lesson). `force = true` is the user-initiated
-     * override.
-     */
-    deleteMemory(args) {
-        return this.client.call("memory.delete", args);
-    }
-    // ---- v0.6.1 — phase ledger (engine 0.5.0+) ----------------------
-    /**
-     * Record a phase entry for `task_id`. Idempotent: re-logging the
-     * same phase returns `newly_recorded: false`. `phase` must be one
-     * of: pre_research, learn, code, test, audit, post_research, fix.
-     *
-     * Pre-#166 this also took a `session_id`, but the writer's MCP
-     * session id and the reader's Claude Code session UUID were two
-     * different id surfaces — the ledger was unreadable across them.
-     * Dropped in favor of per-task scoping; a task that spans multiple
-     * sessions now accumulates phases correctly.
-     */
-    logPhase(args) {
-        return this.client.call("task.log_phase", args);
-    }
-    /**
-     * Fetch the workflow phase ledger for `task_id`. Returns the set of
-     * phases logged + the entries with timestamps, sorted
-     * chronologically.
-     */
-    getTaskLedger(args) {
-        return this.client.call("task.get_ledger", args);
-    }
-}

package/dist/engine-client.test.js

@@ -1,118 +0,0 @@
-/**
- * engine-client subprocess lifecycle tests.
- *
- * #170 (2026-05-17): the first test for engine-client.ts. Spawned by the
- * pkill-validation incident that surfaced a permanent-stuck-state bug
- * when the engine subprocess exits externally:
- *
- *   1. ensureStarted() spawns subprocess + caches a resolved
- *      `startupAck` promise after the initial ping succeeds.
- *   2. Subprocess dies (pkill / OOM / crash).
- *   3. proc.on("exit") nulls `proc` and `reader` but pre-#170 left
- *      `startupAck` truthy.
- *   4. Next call: ensureStarted() returns the cached resolved
- *      startupAck without respawning. call() then sees `proc === null`
- *      and rejects with "engine subprocess not running" — for the rest
- *      of the MCP server's lifetime.
- *
- * This test mocks `node:child_process` so we can simulate the exit
- * event deterministically without spawning a real binary.
- */
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const mockSpawn = vi.fn();
-vi.mock("node:child_process", () => ({
-    spawn: (...args) => mockSpawn(...args),
-}));
-// vi.mock must be set up before the import; dynamic import keeps that ordering.
-const { EngineClient } = await import("./engine-client.js");
-function makeMockProc() {
-    const proc = new EventEmitter();
-    proc.stdin = new PassThrough();
-    proc.stdout = new PassThrough();
-    proc.stderr = new PassThrough();
-    proc.kill = vi.fn();
-    return proc;
-}
-/** Read the next line written to a stream (e.g. mock stdin). */
-function nextLine(stream) {
-    return new Promise((resolve) => {
-        let buf = "";
-        const onData = (chunk) => {
-            buf += chunk.toString("utf8");
-            const nl = buf.indexOf("\n");
-            if (nl >= 0) {
-                stream.off("data", onData);
-                resolve(buf.slice(0, nl));
-            }
-        };
-        stream.on("data", onData);
-    });
-}
-beforeEach(() => {
-    mockSpawn.mockReset();
-});
-afterEach(() => {
-    vi.useRealTimers();
-});
-describe("OpenSquidEngine subprocess lifecycle (#170)", () => {
-    it("respawns the subprocess after an external exit", async () => {
-        const proc1 = makeMockProc();
-        const proc2 = makeMockProc();
-        mockSpawn.mockReturnValueOnce(proc1).mockReturnValueOnce(proc2);
-        // Construct engine via fresh import each test so it has no resolveEngineBin
-        // memo from a previous test (resolveEngineBin reads the env var on each call).
-        process.env.OPENSQUID_ENGINE_BIN = "/fake/path/loop-engine";
-        const engine = new EngineClient();
-        // --- First call: triggers ensureStarted() → spawns proc1, sends ping ---
-        const callP1 = engine.call("task.example", {});
-        // Wait for proc1's stdin to receive the startup ping, then ack it.
-        const startupPingLine = await nextLine(proc1.stdin);
-        const startupReq = JSON.parse(startupPingLine);
-        expect(startupReq.method).toBe("ping");
-        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq.id, result: { ok: true } }) + "\n");
-        // Now proc1's stdin will receive the user's actual call. Respond.
-        const userReqLine = await nextLine(proc1.stdin);
-        const userReq = JSON.parse(userReqLine);
-        expect(userReq.method).toBe("task.example");
-        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: userReq.id, result: { ok: true } }) + "\n");
-        await expect(callP1).resolves.toEqual({ ok: true });
-        // --- Simulate external subprocess exit ---
-        proc1.emit("exit", 1);
-        // Give the exit handler microtasks a tick to run.
-        await new Promise((r) => setImmediate(r));
-        // --- Second call: must respawn proc2 (pre-#170 this would have thrown
-        // "engine subprocess not running" because startupAck was still cached) ---
-        const callP2 = engine.call("task.example", {});
-        const startupPing2 = await nextLine(proc2.stdin);
-        const startupReq2 = JSON.parse(startupPing2);
-        expect(startupReq2.method).toBe("ping");
-        proc2.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq2.id, result: { ok: true } }) + "\n");
-        const userReq2Line = await nextLine(proc2.stdin);
-        const userReq2 = JSON.parse(userReq2Line);
-        expect(userReq2.method).toBe("task.example");
-        proc2.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: userReq2.id, result: { ok: true } }) + "\n");
-        await expect(callP2).resolves.toEqual({ ok: true });
-        expect(mockSpawn).toHaveBeenCalledTimes(2);
-        delete process.env.OPENSQUID_ENGINE_BIN;
-    });
-    it("rejects in-flight pending calls when the subprocess exits", async () => {
-        const proc1 = makeMockProc();
-        mockSpawn.mockReturnValueOnce(proc1);
-        process.env.OPENSQUID_ENGINE_BIN = "/fake/path/loop-engine";
-        const engine = new EngineClient();
-        // Start a call, ack the startup ping, then DON'T respond to the user
-        // call — instead simulate exit.
-        const callP = engine.call("task.example", {});
-        const startupPing = await nextLine(proc1.stdin);
-        const startupReq = JSON.parse(startupPing);
-        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq.id, result: { ok: true } }) + "\n");
-        // Drain the user-call line so the test doesn't hang on backpressure.
-        await nextLine(proc1.stdin);
-        // Simulate crash.
-        proc1.emit("exit", null);
-        await expect(callP).rejects.toThrow(/engine subprocess exited/);
-        delete process.env.OPENSQUID_ENGINE_BIN;
-    });
-});

package/dist/functions/chain_state.d.ts

@@ -1,51 +0,0 @@
-/**
- * `read_chain_state` primitive (T-ASC, ASC.5).
- *
- * Exposes the persisted T-ASC chain-state (or an idle-default shape) to
- * skill YAML `process:` chains. Used by ASC.5's reframed scope-decomposer
- * chain-handoff rules to read enrichment fields (`pre_research_path`,
- * `spec_path`, `task_ids`) when shaping the structured `directive`
- * verdict's `next_action.args`.
- *
- * Returns a stable shape: a non-null object that always has `stage`
- * (defaulting to `'idle'`) and `history` (defaulting to `[]`), plus
- * optional enrichment fields. The `if:` grammar's field access is
- * dot-notation; a stable shape means rule expressions like
- * `chain.pre_research_path` never trigger an undefined-access on the
- * absent-file path.
- *
- * Side-effect-free, no-throw — the underlying `readChainState` returns
- * null on absent/malformed; this primitive coalesces to the idle-default
- * shape. `memoizable: false` because the chain state changes between
- * turns (writers fire on UserPromptSubmit, PreToolUse, log_phase) — a
- * memoized stage would mask the very transitions we're reading.
- *
- * `durable: false` (pure read, cheap stat+readFile). `costEstimateMs: 1`.
- *
- * Imports from: zod, ../runtime/chain_state.js, ../runtime/result.js,
- *   ./registry.js.
- * Imported by: src/runtime/bootstrap.ts (registry wiring).
- */
-import { z } from 'zod';
-import { type ChainStage } from '../runtime/chain_state.js';
-import type { FunctionDef } from './registry.js';
-declare const NoArgs: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
-type NoArgs = z.input<typeof NoArgs>;
-/**
- * The primitive's output shape. `stage` is always present (defaults to
- * 'idle' when no chain file exists). Enrichment fields are optional and
- * appear when their writers populated them.
- */
-export interface ReadChainStateOutput {
-    stage: ChainStage;
-    history: {
-        stage: ChainStage;
-        at: string;
-    }[];
-    pre_research_path?: string;
-    spec_path?: string;
-    task_ids?: string[];
-}
-export declare const ReadChainState: FunctionDef<NoArgs, ReadChainStateOutput>;
-export {};
-//# sourceMappingURL=chain_state.d.ts.map

package/dist/functions/chain_state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain_state.d.ts","sourceRoot":"","sources":["../../src/functions/chain_state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,QAAA,MAAM,MAAM,iDAAwB,CAAC;AACrC,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAErC;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAyBpE,CAAC"}

package/dist/functions/chain_state.js

@@ -1,59 +0,0 @@
-/**
- * `read_chain_state` primitive (T-ASC, ASC.5).
- *
- * Exposes the persisted T-ASC chain-state (or an idle-default shape) to
- * skill YAML `process:` chains. Used by ASC.5's reframed scope-decomposer
- * chain-handoff rules to read enrichment fields (`pre_research_path`,
- * `spec_path`, `task_ids`) when shaping the structured `directive`
- * verdict's `next_action.args`.
- *
- * Returns a stable shape: a non-null object that always has `stage`
- * (defaulting to `'idle'`) and `history` (defaulting to `[]`), plus
- * optional enrichment fields. The `if:` grammar's field access is
- * dot-notation; a stable shape means rule expressions like
- * `chain.pre_research_path` never trigger an undefined-access on the
- * absent-file path.
- *
- * Side-effect-free, no-throw — the underlying `readChainState` returns
- * null on absent/malformed; this primitive coalesces to the idle-default
- * shape. `memoizable: false` because the chain state changes between
- * turns (writers fire on UserPromptSubmit, PreToolUse, log_phase) — a
- * memoized stage would mask the very transitions we're reading.
- *
- * `durable: false` (pure read, cheap stat+readFile). `costEstimateMs: 1`.
- *
- * Imports from: zod, ../runtime/chain_state.js, ../runtime/result.js,
- *   ./registry.js.
- * Imported by: src/runtime/bootstrap.ts (registry wiring).
- */
-import { z } from 'zod';
-import { readChainState } from '../runtime/chain_state.js';
-import { ok } from '../runtime/result.js';
-const NoArgs = z.object({}).strict();
-export const ReadChainState = {
-    name: 'read_chain_state',
-    argSchema: NoArgs,
-    durable: false,
-    memoizable: false,
-    costEstimateMs: 1,
-    execute: async (_args, ctx) => {
-        const state = await readChainState(ctx.sessionId);
-        if (state === null) {
-            // Idle-default shape: callers can always access `chain.stage` and
-            // `chain.history` without an undefined check. Enrichment fields
-            // remain absent (not undefined — the field simply isn't on the
-            // object), so the `if:` grammar's existence checks work correctly.
-            return ok({ stage: 'idle', history: [] });
-        }
-        return ok({
-            stage: state.stage,
-            history: state.history,
-            ...(state.pre_research_path !== undefined
-                ? { pre_research_path: state.pre_research_path }
-                : {}),
-            ...(state.spec_path !== undefined ? { spec_path: state.spec_path } : {}),
-            ...(state.task_ids !== undefined ? { task_ids: state.task_ids } : {}),
-        });
-    },
-};
-//# sourceMappingURL=chain_state.js.map

package/dist/functions/chain_state.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain_state.js","sourceRoot":"","sources":["../../src/functions/chain_state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,cAAc,EAAmB,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAI1C,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAgBrC,MAAM,CAAC,MAAM,cAAc,GAA8C;IACvE,IAAI,EAAE,kBAAkB;IACxB,SAAS,EAAE,MAAM;IACjB,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,KAAK;IACjB,cAAc,EAAE,CAAC;IACjB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QAC5B,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,kEAAkE;YAClE,gEAAgE;YAChE,+DAA+D;YAC/D,mEAAmE;YACnE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAe,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,OAAO,EAAE,CAAC;YACR,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,GAAG,CAAC,KAAK,CAAC,iBAAiB,KAAK,SAAS;gBACvC,CAAC,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE;gBAChD,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxE,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACtE,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/hooks/drift-catalog.d.ts

@@ -1,68 +0,0 @@
-/**
- * Drift catalog — automated SessionEnd scan that surfaces this session's
- * drift signals (0.7.22 / drift D10).
- *
- * D10 in the catalog: previously the agent only catalogued its drifts
- * AFTER the user prompted "please put in all the drifting issues found
- * recently." The whole project is anti-drift; the agent should be
- * cataloguing its own drifts continuously as the dogfood proof.
- *
- * This module scans the session's JSONL transcript at SessionEnd for
- * three classes of drift markers:
- *
- *   1. User-correction phrases in user messages ("you drifted",
- *      "stop X-ing", "no not that", "wrong")
- *   2. Locked-rule citations in user OR assistant messages
- *      (feedback_*, mem-*, drift D\d+)
- *   3. Agent mea-culpa phrases in assistant messages ("I should
- *      have", "my mistake", "I drifted", "I false-stopped")
- *
- * Hits are appended to `<dataRoot>/projects/<uuid>/drift-catalog.jsonl`.
- * One JSON record per line: `{timestamp, session_id, kind, evidence}`.
- *
- * If the project UUID can't be resolved (no `.opensquid/project.json`
- * card in any ancestor of cwd), entries fall back to
- * `<dataRoot>/sessions/<session_id>/drift-catalog.jsonl` so the data
- * isn't lost.
- *
- * Fail-open: any error (missing transcript, bad JSONL, write failure)
- * is swallowed with a stderr warning. SessionEnd is cleanup, not
- * blocking.
- */
-export type DriftMarkerKind = "user_correction" | "rule_citation" | "mea_culpa";
-export interface DriftCatalogEntry {
-    /** ISO timestamp the entry was recorded. */
-    timestamp: string;
-    /** Claude Code session id. */
-    session_id: string;
-    /** Which class of marker fired. */
-    kind: DriftMarkerKind;
-    /** The matched substring (capped at 200 chars). */
-    evidence: string;
-    /** Optional surrounding context (up to 200 chars on either side). */
-    context?: string;
-}
-/**
- * Scan a transcript and return all detected drift markers. Pure
- * function; exported for direct testing.
- */
-export declare function scanTranscriptForDrift(lines: string[], sessionId: string, now?: () => Date): DriftCatalogEntry[];
-/**
- * Run the SessionEnd drift-catalog scan + persist results. Returns
- * the number of entries written (0 if nothing matched OR write failed).
- */
-export declare function runDriftCatalogScan(input: {
-    sessionId: string;
-    transcriptPath?: string;
-    cwd?: string;
-    dataRoot?: string;
-    now?: () => Date;
-}): Promise<number>;
-/**
- * Decide where to write the catalog: project-scoped if we can resolve
- * a project UUID from cwd; session-scoped fallback otherwise.
- *
- * Exported for testing.
- */
-export declare function resolveCatalogPath(cwd: string | undefined, sessionId: string, dataRoot?: string): Promise<string>;
-//# sourceMappingURL=drift-catalog.d.ts.map

package/dist/hooks/drift-catalog.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drift-catalog.d.ts","sourceRoot":"","sources":["../../src.legacy/hooks/drift-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAUH,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,eAAe,GAAG,WAAW,CAAC;AAEhF,MAAM,WAAW,iBAAiB;IAChC,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,IAAI,EAAE,eAAe,CAAC;IACtB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAiCD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAM,IAAuB,GACjC,iBAAiB,EAAE,CAmBrB;AA0BD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsBlB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CAajB"}