@selvakumaresra/specship 0.7.0 → 0.10.0

package/dist/reflect/sweep.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Reflection orchestration (REQ-REFLECT-001 / 006).
+ *
+ * `analyze` runs the miner and persists the batch, returning the current open
+ * proposals — this is what the on-demand button and `specship reflect` call.
+ *
+ * `sweep` does the same but additionally returns the proposals that should fire
+ * a notification: freshly-inserted (not previously seen, applied, or dismissed)
+ * AND high-severity. Already-seen and lower-severity findings are persisted and
+ * listed, but never re-notified.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyze = analyze;
+exports.sweep = sweep;
+const miner_1 = require("./miner");
+const store_1 = require("./store");
+function analyze(db, ctx, now = () => Date.now()) {
+    const store = new store_1.ReflectStore(db, now);
+    const mined = (0, miner_1.mineProposals)(db, ctx);
+    if (mined.length > 0)
+        store.upsertMined(mined);
+    return { open: store.list('open'), empty: mined.length === 0 };
+}
+function sweep(db, ctx, now = () => Date.now()) {
+    const store = new store_1.ReflectStore(db, now);
+    const mined = (0, miner_1.mineProposals)(db, ctx);
+    const notify = [];
+    if (mined.length > 0) {
+        const { stored, insertedHashes } = store.upsertMined(mined);
+        for (const p of stored) {
+            // Notify only on a brand-new, still-open, high-severity proposal. A row
+            // that already existed (even if re-mined) is not "new"; an applied or
+            // dismissed one is filtered by the open check.
+            if (insertedHashes.has(p.contentHash) && p.severity === 'high' && p.state === 'open') {
+                notify.push(p);
+            }
+        }
+    }
+    return { open: store.list('open'), empty: mined.length === 0, notify };
+}
+//# sourceMappingURL=sweep.js.map

package/dist/reflect/sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sweep.js","sourceRoot":"","sources":["../../src/reflect/sweep.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAmBH,0BASC;AAED,sBAoBC;AA/CD,mCAAwC;AACxC,mCAAuC;AAevC,SAAgB,OAAO,CACrB,EAAkB,EAClB,GAAmB,EACnB,MAAoB,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAEpC,MAAM,KAAK,GAAG,IAAI,oBAAY,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,IAAA,qBAAa,EAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACrC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC/C,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;AACjE,CAAC;AAED,SAAgB,KAAK,CACnB,EAAkB,EAClB,GAAmB,EACnB,MAAoB,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;IAEpC,MAAM,KAAK,GAAG,IAAI,oBAAY,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,IAAA,qBAAa,EAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACrC,MAAM,MAAM,GAAe,EAAE,CAAC;IAC9B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5D,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;YACvB,wEAAwE;YACxE,sEAAsE;YACtE,+CAA+C;YAC/C,IAAI,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;gBACrF,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;AACzE,CAAC"}

package/dist/reflect/targets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Target resolution (REQ-REFLECT-002).
+ *
+ * Each proposal type maps to a concrete write target with its own marker
+ * convention so the apply can be idempotent (re-apply = no-op) and reversible
+ * (undo strips exactly what apply added — REQ-REFLECT-004):
+ *
+ *   - memory_rule, project scope  → a `<!-- SPECSHIP_LEARNING:<id> -->` block in
+ *                                    the project CLAUDE.md
+ *   - memory_rule, portable scope → a new `~/.claude/memory/<slug>.md` note
+ *                                    (carrying a `specship_proposal:` frontmatter
+ *                                    marker) + a one-line `MEMORY.md` pointer
+ *   - skill                       → a new `commands/ss-<name>.md` (carrying a
+ *                                    leading marker comment)
+ *   - hook                        → a hook entry merged into `.claude/settings.json`
+ *
+ * This module is pure: it builds the payload + path, it does not touch disk.
+ */
+import { Proposal, ProposalEvidence, ProposalSeverity, ProposalType, ReflectContext } from './types';
+/** Marker bounding an engine-written block in CLAUDE.md / command files. */
+export declare function learningMarkers(id: string): {
+    start: string;
+    end: string;
+};
+/** Frontmatter marker line stamped into an engine-created memory note. */
+export declare function memoryNoteMarker(id: string): string;
+/**
+ * Assemble a fully-formed Proposal from a rule's raw inputs. Computes the target
+ * path, builds the type-specific payload (including its markers), and derives the
+ * stable content hash. `createdAt`/`updatedAt` are stamped by the caller (the
+ * store) — here they default to 0 so the object is pure/deterministic.
+ */
+export declare function buildProposal(ctx: ReflectContext, input: {
+    type: ProposalType;
+    severity: ProposalSeverity;
+    title: string;
+    body: string;
+    evidence: ProposalEvidence;
+    /** memory_rule scope: 'project' → CLAUDE.md, 'portable' → ~/.claude/memory note. */
+    scope?: 'project' | 'portable';
+    /** The durable rule/skill/hook content, type-dependent. */
+    content: string;
+    /** Hook-only: the settings.json event + matcher + command. */
+    hook?: {
+        event: string;
+        matcher: string;
+        command: string;
+    };
+    /** A short name seed (for slug / command name). */
+    nameSeed: string;
+}): Proposal;
+//# sourceMappingURL=targets.d.ts.map

package/dist/reflect/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../src/reflect/targets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEhB,gBAAgB,EAChB,YAAY,EACZ,cAAc,EAEf,MAAM,SAAS,CAAC;AAEjB,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAK1E;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEnD;AAUD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE;IACL,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,oFAAoF;IACpF,KAAK,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IAC/B,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB,GACA,QAAQ,CAsEV"}

package/dist/reflect/targets.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Target resolution (REQ-REFLECT-002).
+ *
+ * Each proposal type maps to a concrete write target with its own marker
+ * convention so the apply can be idempotent (re-apply = no-op) and reversible
+ * (undo strips exactly what apply added — REQ-REFLECT-004):
+ *
+ *   - memory_rule, project scope  → a `<!-- SPECSHIP_LEARNING:<id> -->` block in
+ *                                    the project CLAUDE.md
+ *   - memory_rule, portable scope → a new `~/.claude/memory/<slug>.md` note
+ *                                    (carrying a `specship_proposal:` frontmatter
+ *                                    marker) + a one-line `MEMORY.md` pointer
+ *   - skill                       → a new `commands/ss-<name>.md` (carrying a
+ *                                    leading marker comment)
+ *   - hook                        → a hook entry merged into `.claude/settings.json`
+ *
+ * This module is pure: it builds the payload + path, it does not touch disk.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.learningMarkers = learningMarkers;
+exports.memoryNoteMarker = memoryNoteMarker;
+exports.buildProposal = buildProposal;
+const path = __importStar(require("path"));
+const hash_1 = require("./hash");
+/** Marker bounding an engine-written block in CLAUDE.md / command files. */
+function learningMarkers(id) {
+    return {
+        start: `<!-- SPECSHIP_LEARNING:${id} -->`,
+        end: `<!-- /SPECSHIP_LEARNING:${id} -->`,
+    };
+}
+/** Frontmatter marker line stamped into an engine-created memory note. */
+function memoryNoteMarker(id) {
+    return `specship_proposal: ${id}`;
+}
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/(^-|-$)/g, '')
+        .slice(0, 48) || 'learning';
+}
+/**
+ * Assemble a fully-formed Proposal from a rule's raw inputs. Computes the target
+ * path, builds the type-specific payload (including its markers), and derives the
+ * stable content hash. `createdAt`/`updatedAt` are stamped by the caller (the
+ * store) — here they default to 0 so the object is pure/deterministic.
+ */
+function buildProposal(ctx, input) {
+    let targetKind;
+    let targetPath;
+    let payload;
+    if (input.type === 'memory_rule') {
+        if (input.scope === 'portable') {
+            const slug = slugify(input.nameSeed);
+            targetKind = 'memory_note';
+            targetPath = path.join(ctx.homeDir, '.claude', 'memory', `${slug}.md`);
+            // Hash needs a deterministic id; derive a provisional one from the slug so
+            // the marker is stable, then fold everything into the final hash below.
+            const note = renderMemoryNote(slug, input.title, input.content);
+            const indexLine = `- [${input.title}](${slug}.md) — ${firstSentence(input.body)}`;
+            payload = { kind: 'memory_note', slug, note, indexLine };
+        }
+        else {
+            targetKind = 'claude_md';
+            targetPath = path.join(ctx.projectRoot, 'CLAUDE.md');
+            // markerId is finalized after we know the hash; use a placeholder then
+            // re-render once hashed (below) so the block carries its own id.
+            payload = { kind: 'claude_md', markerId: '', block: '' };
+        }
+    }
+    else if (input.type === 'skill') {
+        const name = slugify(input.nameSeed).replace(/^ss-/, '');
+        targetKind = 'command';
+        targetPath = path.join(ctx.projectRoot, 'commands', `ss-${name}.md`);
+        payload = { kind: 'command', name: `ss-${name}`, content: '' };
+    }
+    else {
+        // hook
+        targetKind = 'settings_hook';
+        targetPath = path.join(ctx.projectRoot, '.claude', 'settings.json');
+        const h = input.hook;
+        payload = {
+            kind: 'settings_hook',
+            event: h.event,
+            matcher: h.matcher,
+            entry: { type: 'command', command: h.command },
+        };
+    }
+    // First-pass hash over the (still-placeholder) identity, then bake the id into
+    // marker-bearing payloads and re-hash so the persisted hash matches the bytes.
+    let contentHash = (0, hash_1.proposalHash)({ type: input.type, targetKind, targetPath, payload });
+    if (payload.kind === 'claude_md') {
+        const { start, end } = learningMarkers(contentHash);
+        const block = `${start}\n${renderClaudeRule(input.title, input.content)}\n${end}`;
+        payload = { kind: 'claude_md', markerId: contentHash, block };
+        contentHash = (0, hash_1.proposalHash)({ type: input.type, targetKind, targetPath, payload });
+    }
+    else if (payload.kind === 'command') {
+        const content = renderCommand(contentHash, payload.name, input.title, input.content);
+        payload = { kind: 'command', name: payload.name, content };
+        contentHash = (0, hash_1.proposalHash)({ type: input.type, targetKind, targetPath, payload });
+    }
+    return {
+        contentHash,
+        type: input.type,
+        severity: input.severity,
+        title: input.title,
+        body: input.body,
+        targetKind,
+        targetPath,
+        payload,
+        evidence: input.evidence,
+        state: 'open',
+        createdAt: 0,
+        updatedAt: 0,
+        appliedAt: null,
+    };
+}
+function firstSentence(s) {
+    const m = s.split(/(?<=[.!?])\s/)[0] ?? s;
+    return m.length > 100 ? m.slice(0, 100) + '…' : m;
+}
+/** The rule body written inside a CLAUDE.md marked block. */
+function renderClaudeRule(title, content) {
+    return `## ${title}\n\n${content}\n\n_(Added by SpecShip reflection — edit or remove freely.)_`;
+}
+/** A self-contained memory note matching the user's memory-file convention. */
+function renderMemoryNote(slug, title, content) {
+    return [
+        '---',
+        `name: ${slug}`,
+        `description: ${firstSentence(title)}`,
+        `${memoryNoteMarker(slug)}`,
+        'metadata:',
+        '  type: feedback',
+        '---',
+        '',
+        content,
+        '',
+    ].join('\n');
+}
+/** A minimal slash-command skill file. */
+function renderCommand(id, name, title, content) {
+    const { start, end } = learningMarkers(id);
+    return [
+        start,
+        `# ${title}`,
+        '',
+        `> \`/${name}\` — proposed by SpecShip reflection from a recurring pattern.`,
+        '',
+        content,
+        '',
+        end,
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=targets.js.map

package/dist/reflect/targets.js.map

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

package/dist/reflect/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Reflection engine types (REFLECT-DOC).
+ *
+ * A Proposal is a durable, human-gated self-improvement suggestion mined from
+ * the ingested `claude_*` transcript tables. It is never advisory text alone —
+ * it resolves to a concrete, previewable file change (REQ-REFLECT-002), keyed by
+ * a stable `contentHash` so re-mining the same pattern converges to one row
+ * (REQ-REFLECT-007). The engine PROPOSES; bytes reach disk only on an explicit
+ * per-proposal apply (REQ-REFLECT-005).
+ */
+/** The kind of durable artifact a proposal produces. */
+export type ProposalType = 'memory_rule' | 'skill' | 'hook';
+/** Severity, reusing the tips engine's scale. `high` drives sweep notifications. */
+export type ProposalSeverity = 'high' | 'warn' | 'info';
+/** Persisted lifecycle state (REQ-REFLECT-007). */
+export type ProposalState = 'open' | 'applied' | 'undone' | 'dismissed';
+/** The concrete file the apply writes. */
+export type TargetKind = 'claude_md' | 'memory_note' | 'command' | 'settings_hook';
+/** What the proposal was derived from, so the user can judge it (REQ-REFLECT-001). */
+export interface ProposalEvidence {
+    /** Contributing session ids. */
+    sessions: string[];
+    /** Contributing prompt ids. */
+    prompts: string[];
+    /** Human-readable one-line summary of the observed pattern. */
+    detail: string;
+}
+/**
+ * Artifact-type-specific payload — the exact intended content the preview
+ * renders and the apply writes (REQ-REFLECT-002.A4). Discriminated on `kind`,
+ * which matches the proposal's `targetKind`.
+ */
+export type ProposalPayload = {
+    kind: 'claude_md';
+    markerId: string;
+    block: string;
+} | {
+    kind: 'memory_note';
+    slug: string;
+    note: string;
+    indexLine: string;
+} | {
+    kind: 'command';
+    name: string;
+    content: string;
+} | {
+    kind: 'settings_hook';
+    event: string;
+    matcher: string;
+    entry: Record<string, unknown>;
+};
+/** A single reflection proposal. */
+export interface Proposal {
+    /** Stable id over (type, targetKind, targetPath, payload) — excludes evidence/timestamps. */
+    contentHash: string;
+    type: ProposalType;
+    severity: ProposalSeverity;
+    title: string;
+    body: string;
+    targetKind: TargetKind;
+    /** Absolute path the apply will write. */
+    targetPath: string;
+    payload: ProposalPayload;
+    evidence: ProposalEvidence;
+    state: ProposalState;
+    createdAt: number;
+    updatedAt: number;
+    appliedAt: number | null;
+}
+/** Result of applying a proposal (REQ-REFLECT-004). */
+export type ApplyOutcome = 'applied' | 'unchanged' | 'conflict';
+/** Result of undoing a proposal (REQ-REFLECT-004.A3). */
+export type UndoOutcome = 'undone' | 'noop';
+/** A non-mutating preview of the change a proposal would make (REQ-REFLECT-003). */
+export interface PreviewResult {
+    targetPath: string;
+    targetKind: TargetKind;
+    /** Whether the target file already exists on disk. */
+    exists: boolean;
+    /** Current file content (empty string when the file is absent). */
+    before: string;
+    /** File content after the change would be applied. */
+    after: string;
+    /** A line-based unified-style diff of before → after. */
+    diff: string;
+    /** Set when the apply would be refused — a non-marked file already occupies the path. */
+    conflict?: boolean;
+}
+/** Options the engine needs to resolve target paths. */
+export interface ReflectContext {
+    /** Absolute project root (for project CLAUDE.md / commands / .claude/settings.json). */
+    projectRoot: string;
+    /** Home directory (for ~/.claude/memory notes). */
+    homeDir: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/reflect/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/reflect/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,wDAAwD;AACxD,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,oFAAoF;AACpF,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAExD,mDAAmD;AACnD,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;AAExE,0CAA0C;AAC1C,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,eAAe,CAAC;AAEnF,sFAAsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC;AAE9F,oCAAoC;AACpC,MAAM,WAAW,QAAQ;IACvB,6FAA6F;IAC7F,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,UAAU,CAAC;IACvB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAEhE,yDAAyD;AACzD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5C,oFAAoF;AACpF,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,sDAAsD;IACtD,MAAM,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B,wFAAwF;IACxF,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/reflect/types.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Reflection engine types (REFLECT-DOC).
+ *
+ * A Proposal is a durable, human-gated self-improvement suggestion mined from
+ * the ingested `claude_*` transcript tables. It is never advisory text alone —
+ * it resolves to a concrete, previewable file change (REQ-REFLECT-002), keyed by
+ * a stable `contentHash` so re-mining the same pattern converges to one row
+ * (REQ-REFLECT-007). The engine PROPOSES; bytes reach disk only on an explicit
+ * per-proposal apply (REQ-REFLECT-005).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/reflect/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/reflect/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG"}

package/dist/resolution/domain-gap-seed.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Domain gap-seed (REQ-DOMAIN-003).
+ *
+ * A read-only pass that surfaces what the domain knowledge layer does NOT yet
+ * cover, so an author (or the `/ss-domain` command, REQ-DOMAIN-004) can decide
+ * what to document next. It answers two questions against current DB state:
+ *
+ *   - which structural code entities (classes, structs, interfaces, routes,
+ *     components) are reached by NO domain fact; and
+ *   - which non-domain specs (documents, requirements, …) have NO domain fact
+ *     hanging off them.
+ *
+ * A domain fact carries no direct domain→code rows. It reaches code transitively
+ * through its spec-tier chain (`parentId` + `metadata.depends_on`), resolved by
+ * {@link SpecLinkResolver.getInheritedLinks} (REQ-DOMAIN-002). An entity is
+ * "documented" when some domain fact's inherited links resolve to that entity's
+ * node; a spec is "documented" when some domain fact's spec-tier chain reaches
+ * it. Everything else is a gap.
+ *
+ * COMPUTED from live state — writes nothing. Like the spec funnel
+ * (`computeSpecFunnel`), the result is always fresh and needs no bookkeeping.
+ */
+import { NodeKind, SpecKind } from '../types';
+import { QueryBuilder } from '../db/queries';
+import { SpecQueries } from '../db/spec-queries';
+import { SpecLinkResolver } from './spec-link-resolver';
+/** A code entity not yet reached by any domain fact. */
+export interface GapSeedEntity {
+    nodeId: string;
+    name: string;
+    qualifiedName: string;
+    kind: NodeKind;
+    filePath: string;
+}
+/** A non-domain spec with no domain fact hanging off it. */
+export interface GapSeedSpec {
+    id: string;
+    title: string;
+    kind: SpecKind;
+}
+/**
+ * Coverage tally over the entity ∪ spec universe. `documented + gaps` always
+ * equals the total count of in-scope entities plus non-domain specs.
+ */
+export interface DomainCoverage {
+    documented: number;
+    gaps: number;
+}
+export interface DomainGapSeed {
+    entities: GapSeedEntity[];
+    specs: GapSeedSpec[];
+    coverage: DomainCoverage;
+}
+/**
+ * Compute the domain gap-seed: the in-scope entities and non-domain specs that
+ * no domain fact yet covers. Read-only — issues only `SELECT`s through the
+ * passed query objects and the resolver's read-time `getInheritedLinks`.
+ */
+export declare function computeDomainGapSeed(queries: QueryBuilder, specQueries: SpecQueries, resolver: SpecLinkResolver): DomainGapSeed;
+//# sourceMappingURL=domain-gap-seed.d.ts.map

package/dist/resolution/domain-gap-seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-gap-seed.d.ts","sourceRoot":"","sources":["../../src/resolution/domain-gap-seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAQ,QAAQ,EAAQ,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAWxD,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,4DAA4D;AAC5D,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,gBAAgB,GACzB,aAAa,CAqDf"}

package/dist/resolution/domain-gap-seed.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Domain gap-seed (REQ-DOMAIN-003).
+ *
+ * A read-only pass that surfaces what the domain knowledge layer does NOT yet
+ * cover, so an author (or the `/ss-domain` command, REQ-DOMAIN-004) can decide
+ * what to document next. It answers two questions against current DB state:
+ *
+ *   - which structural code entities (classes, structs, interfaces, routes,
+ *     components) are reached by NO domain fact; and
+ *   - which non-domain specs (documents, requirements, …) have NO domain fact
+ *     hanging off them.
+ *
+ * A domain fact carries no direct domain→code rows. It reaches code transitively
+ * through its spec-tier chain (`parentId` + `metadata.depends_on`), resolved by
+ * {@link SpecLinkResolver.getInheritedLinks} (REQ-DOMAIN-002). An entity is
+ * "documented" when some domain fact's inherited links resolve to that entity's
+ * node; a spec is "documented" when some domain fact's spec-tier chain reaches
+ * it. Everything else is a gap.
+ *
+ * COMPUTED from live state — writes nothing. Like the spec funnel
+ * (`computeSpecFunnel`), the result is always fresh and needs no bookkeeping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDomainGapSeed = computeDomainGapSeed;
+/** The structural node kinds the gap-seed considers "domain-worthy" entities. */
+const IN_SCOPE_ENTITY_KINDS = [
+    'class',
+    'struct',
+    'interface',
+    'route',
+    'component',
+];
+/**
+ * Compute the domain gap-seed: the in-scope entities and non-domain specs that
+ * no domain fact yet covers. Read-only — issues only `SELECT`s through the
+ * passed query objects and the resolver's read-time `getInheritedLinks`.
+ */
+function computeDomainGapSeed(queries, specQueries, resolver) {
+    // In-scope entities: every structural code symbol a domain fact could document.
+    const entities = IN_SCOPE_ENTITY_KINDS.flatMap((k) => queries.getNodesByKind(k));
+    // Build the documented sets by walking each domain fact's spec-tier chain.
+    const allSpecs = specQueries.getAllSpecs();
+    const documentedNodeIds = new Set();
+    const documentedSpecIds = new Set();
+    for (const spec of allSpecs) {
+        if (spec.kind !== 'domain')
+            continue;
+        const inherited = resolver.getInheritedLinks(spec);
+        for (const { link } of inherited.links) {
+            if (link.resolvedNodeId)
+                documentedNodeIds.add(link.resolvedNodeId);
+        }
+        // Every indexed spec the fact reaches counts as documented — even one that
+        // contributes no code link of its own (REQ-DOMAIN-003.A2).
+        for (const reached of inherited.visitedSpecIds) {
+            documentedSpecIds.add(reached);
+        }
+    }
+    // Gap entities: in-scope entities no domain fact resolves to (A1, A2).
+    const gapEntities = entities
+        .filter((n) => !documentedNodeIds.has(n.id))
+        .map((n) => ({
+        nodeId: n.id,
+        name: n.name,
+        qualifiedName: n.qualifiedName,
+        kind: n.kind,
+        filePath: n.filePath,
+    }));
+    // Non-domain specs are the spec-side universe; a domain fact is never its own
+    // documentation target.
+    const nonDomainSpecs = allSpecs.filter((s) => s.kind !== 'domain');
+    const gapSpecs = nonDomainSpecs
+        .filter((s) => !documentedSpecIds.has(s.id))
+        .map((s) => ({ id: s.id, title: s.title, kind: s.kind }));
+    // Coverage over the entity ∪ spec universe (A3): the denominator is the total
+    // count of in-scope entities plus non-domain specs, so documented + gaps
+    // always reconstitutes it exactly.
+    const gaps = gapEntities.length + gapSpecs.length;
+    const documented = entities.length + nonDomainSpecs.length - gaps;
+    return {
+        entities: gapEntities,
+        specs: gapSpecs,
+        coverage: { documented, gaps },
+    };
+}
+//# sourceMappingURL=domain-gap-seed.js.map

package/dist/resolution/domain-gap-seed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-gap-seed.js","sourceRoot":"","sources":["../../src/resolution/domain-gap-seed.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;AAoDH,oDAyDC;AAtGD,iFAAiF;AACjF,MAAM,qBAAqB,GAAe;IACxC,OAAO;IACP,QAAQ;IACR,WAAW;IACX,OAAO;IACP,WAAW;CACZ,CAAC;AAiCF;;;;GAIG;AACH,SAAgB,oBAAoB,CAClC,OAAqB,EACrB,WAAwB,EACxB,QAA0B;IAE1B,gFAAgF;IAChF,MAAM,QAAQ,GAAW,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAC3D,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAC1B,CAAC;IAEF,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC;IAC3C,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC5C,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;IAE5C,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;YAAE,SAAS;QACrC,MAAM,SAAS,GAAG,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACnD,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;YACvC,IAAI,IAAI,CAAC,cAAc;gBAAE,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACtE,CAAC;QACD,2EAA2E;QAC3E,2DAA2D;QAC3D,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,cAAc,EAAE,CAAC;YAC/C,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,uEAAuE;IACvE,MAAM,WAAW,GAAoB,QAAQ;SAC1C,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SAC3C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,MAAM,EAAE,CAAC,CAAC,EAAE;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,aAAa,EAAE,CAAC,CAAC,aAAa;QAC9B,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,QAAQ,EAAE,CAAC,CAAC,QAAQ;KACrB,CAAC,CAAC,CAAC;IAEN,8EAA8E;IAC9E,wBAAwB;IACxB,MAAM,cAAc,GAAW,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAkB,cAAc;SAC3C,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SAC3C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAE5D,8EAA8E;IAC9E,yEAAyE;IACzE,mCAAmC;IACnC,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IAClD,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC;IAElE,OAAO;QACL,QAAQ,EAAE,WAAW;QACrB,KAAK,EAAE,QAAQ;QACf,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;KAC/B,CAAC;AACJ,CAAC"}

package/dist/resolution/spec-link-resolver.d.ts

@@ -27,7 +27,7 @@
  * Highest-confidence signal wins per logical key — `upsertSpecLink` enforces
  * this.
  */
-import { Spec } from '../types';
+import { Spec, SpecLink } from '../types';
 import { QueryBuilder } from '../db/queries';
 import { SpecQueries } from '../db/spec-queries';
 import { SpecLinkCandidate } from '../extraction/specs/types';
@@ -45,6 +45,35 @@ export interface SpecLinkResolverStats {
     candidatesApplied: number;
     commentLinksApplied: number;
 }
+/** One code link inherited by a spec through a spec→spec dependency edge. */
+export interface InheritedLink {
+    /** The dependency spec id whose `implements` link this is. */
+    viaSpecId: string;
+    /** The inherited link itself (carries live `state` / `driftAxis`). */
+    link: SpecLink;
+}
+/** Result of {@link SpecLinkResolver.getInheritedLinks}. */
+export interface InheritedLinksResult {
+    /** Code links reached transitively through the spec's parent / depends_on chain. */
+    links: InheritedLink[];
+    /** Declared dependency spec ids that don't resolve to an indexed spec (gaps). */
+    gaps: string[];
+    /**
+     * Every *indexed* spec id reached through the spec-tier chain (excludes the
+     * originating spec and the unresolved `gaps`). A spec a fact reaches but that
+     * contributes no code link still appears here, so consumers like the domain
+     * gap-seed (REQ-DOMAIN-003) can treat "reached by a domain fact" as documented
+     * even when the reached spec carries no `spec_links` of its own.
+     */
+    visitedSpecIds: string[];
+}
+/**
+ * The spec ids a spec links to at the spec tier: its `parentId` plus every
+ * entry of `metadata.depends_on` (REQ-DOMAIN-002). `depends_on` may be a
+ * single string or a string[]; both normalize to a deduped list of non-empty
+ * ids.
+ */
+export declare function sourceSpecIds(spec: Spec): string[];
 export declare class SpecLinkResolver {
     private queries;
     private specQueries;
@@ -98,6 +127,22 @@ export declare class SpecLinkResolver {
      * needed, call specship_link_verify to take state back to `verified`.
      */
     markSpecDrifted(specId: string, newSpecHash: string): number;
+    /**
+     * Compute the code links a spec inherits transitively through its
+     * spec→spec edges (`parentId` + `metadata.depends_on`). A `domain` fact
+     * carries NO direct domain→code rows; its code association and drift state
+     * are derived here by following those spec edges to requirement specs and
+     * reusing *their* `spec_links` — whose `resolved_node_id`/`state` the normal
+     * `resolveAll`/`resolveLinksForFiles` pass already refreshed this sync. So
+     * "re-resolved after each sync" holds with no stored domain rows, and drift
+     * surfaces automatically through each inherited link's live `state`.
+     *
+     * Read-time derivation only — writes nothing. Cycle-guarded via a visited
+     * `Set`, depth-capped (default {@link INHERITED_LINK_MAX_DEPTH}). A declared
+     * dependency that doesn't resolve to an indexed spec is returned in `gaps`
+     * (an unlinked/proposed fact, never an error — REQ-DOMAIN-002.A3).
+     */
+    getInheritedLinks(spec: Spec, maxDepth?: number): InheritedLinksResult;
     private makeStats;
 }
 //# sourceMappingURL=spec-link-resolver.d.ts.map