@treeseed/dsh-chapters 0.1.0

package/lib/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,gBAAgB,EAAkB,MAAM,aAAa,CAAA;AAW9D,gFAAgF;AAChF,MAAM,CAAC,MAAM,WAAW,GAAiB;IACvC,GAAG,gBAAgB;IACnB,IAAI,EAAE,KAAK;IACX,QAAQ,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,SAAS,OAAO,CAAC,MAAM,EAAE;CACjD,CAAA;AAED,+EAA+E;AAC/E,2EAA2E;AAC3E,yEAAyE;AACzE,0EAA0E;AAC1E,MAAM,QAAQ,GAAG,IAAI,GAAG,CAA6B,CAAC,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;AAE5E,MAAM,UAAU,gBAAgB,CAAC,QAAsB;IACrD,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAA+C;IAC5E,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAAA;IAClC,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACnC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,+BAA+B,OAAO,CAAC,MAAM,GAAG,CAAC,CAAA;IAC9F,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,UAAwB,EAAE,MAAc;IACtE,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,UAAU,CAAA;IACxC,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,qCAAqC,CAAC,CAAA;IAC3F,CAAC;IACD,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,sCAAsC,UAAU,oDAAoD,CAAC,CAAA;IAC1J,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC"}

package/lib/redact.d.ts

@@ -0,0 +1,24 @@
+export interface RedactPattern {
+    name: string;
+    /** Global regex; the secret is the whole match unless `secretGroup` names a capture group. */
+    regex: RegExp;
+    /** Capture group holding the secret (e.g. keep `token=`, redact the value). Default: whole match. */
+    secretGroup?: number;
+}
+/** Built-in set (record §9). New patterns are config additions, not magic. */
+export declare const DEFAULT_REDACTIONS: readonly RedactPattern[];
+export interface RedactionResult {
+    text: string;
+    /** Number of secret occurrences replaced. */
+    count: number;
+    /** Distinct markers produced (for tests/audit; order of first appearance). */
+    markers: string[];
+}
+/**
+ * Replace every pattern match's secret with its stable marker.
+ * `secretGroup` semantics: the named group is the LABEL to keep; the secret
+ * is the rest of the match (url-credential-param, bearer). Without it, the
+ * whole match is the secret. Markers never re-match any pattern (verified by
+ * test), so passes compose safely.
+ */
+export declare function redactText(text: string, patterns?: readonly RedactPattern[]): RedactionResult;

package/lib/redact.js

@@ -0,0 +1,85 @@
+/**
+ * Deterministic credential redaction (knowledge-repo.md §9).
+ *
+ * The user's position, adopted: credentials only, deterministic patterns only,
+ * everything else byte-identical — the character of the conversation is
+ * historical value and stays intact. The marker is deliberate and stable:
+ *   ⟦redacted:credential sha256=8f3a1c2b⟧
+ * (a) obviously not a real value to any model reading a chapter,
+ * (b) deterministic per secret — same secret, same marker, so diffs and
+ *     cross-chapter greps stay stable,
+ * (c) leaks nothing but an 8-hex prefix hash, which is also what lets a user
+ *     ask "which secrets touched my sessions" without exposing them.
+ *
+ * Patterns are conservative by design and config-extensible; redaction is a
+ * speed bump, not a guarantee (the record says so, and so does the in-repo
+ * notice). Applied once, at the render chokepoint (src/render.ts), so chapters
+ * and artifact files are both covered without caller changes.
+ */
+import { createHash } from 'node:crypto';
+/** Built-in set (record §9). New patterns are config additions, not magic. */
+export const DEFAULT_REDACTIONS = [
+    { name: 'pem-private-key', regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g },
+    { name: 'aws-access-key-id', regex: /\bAKIA[0-9A-Z]{16}\b/g },
+    { name: 'github-token', regex: /\b(?:ghp|gho|ghs|ghu)_[A-Za-z0-9]{16,}\b/g },
+    { name: 'github-fine-grained', regex: /\bgithub_pat_[A-Za-z0-9_]{16,}\b/g },
+    { name: 'openai-style-key', regex: /\bsk-[A-Za-z0-9_-]{16,}\b/g },
+    { name: 'jwt', regex: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\b/g },
+    { name: 'bearer-token', regex: /\b(Bearer\s+)[A-Za-z0-9._~+/=-]{16,}/gi, secretGroup: 1 },
+    { name: 'url-credential-param', regex: /([?&](?:token|api[_-]?key|apikey|key|secret|password)=)[^&\s"'`]+/gi, secretGroup: 1 },
+];
+/**
+ * `Bearer <tok>` → redact the token, keep the `Bearer ` label: the pattern's
+ * `secretGroup` names the capture that is NOT the secret; here we invert —
+ * the label is group 1, so the secret is the remainder of the match after
+ * the group. Implemented via a post-step in redactText (label-aware patterns).
+ */
+function markerFor(secret) {
+    const h = createHash('sha256').update(secret, 'utf8').digest('hex').slice(0, 8);
+    return `⟦redacted:credential sha256=${h}⟧`;
+}
+/**
+ * Replace every pattern match's secret with its stable marker.
+ * `secretGroup` semantics: the named group is the LABEL to keep; the secret
+ * is the rest of the match (url-credential-param, bearer). Without it, the
+ * whole match is the secret. Markers never re-match any pattern (verified by
+ * test), so passes compose safely.
+ */
+export function redactText(text, patterns = DEFAULT_REDACTIONS) {
+    let out = text;
+    let count = 0;
+    const markers = [];
+    for (const p of patterns) {
+        const re = new RegExp(p.regex.source, p.regex.flags.includes('g') ? p.regex.flags : p.regex.flags + 'g');
+        const matches = Array.from(out.matchAll(re));
+        if (matches.length === 0)
+            continue;
+        // splice back-to-front so earlier indices stay valid
+        for (let i = matches.length - 1; i >= 0; i -= 1) {
+            const m = matches[i];
+            const whole = m[0];
+            let keep = '';
+            let secret = whole;
+            // label-group patterns (bearer, url-credential): the named group is a
+            // PREFIX of the match and is kept; the remainder is the secret. Any
+            // other shape falls through to whole-match redaction (safe default).
+            if (p.secretGroup !== undefined) {
+                const label = m[p.secretGroup];
+                if (typeof label === 'string' && label.length > 0 && whole.startsWith(label)) {
+                    keep = label;
+                    secret = whole.slice(label.length);
+                }
+            }
+            if (secret.length === 0)
+                continue;
+            const marker = markerFor(secret);
+            const start = m.index + keep.length;
+            out = out.slice(0, start) + marker + out.slice(start + secret.length);
+            count += 1;
+            if (!markers.includes(marker))
+                markers.push(marker);
+        }
+    }
+    return { text: out, count, markers };
+}
+//# sourceMappingURL=redact.js.map

package/lib/redact.js.map

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

package/lib/registry.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Registry — pure ancestry/numbering state. No cordis, no zod, no I/O: this is
+ * the L0 layer (docs/development.md § Test Layers); `src/store.ts` is the thin
+ * storage-domain adapter over it, deliberately untested because it is glue.
+ *
+ * The registry is the SOLE authority on ancestry (contract.md § Lineage: the
+ * kernel header carries `parentSession` for seed lineage we deliberately do not
+ * use; the UI graph will show our children as unrelated roots). Corruptions it
+ * must survive: cycles (walk guard throws, never hangs), duplicate chapter ids
+ * (append is idempotent), retry-after-crash (reserve is attempt-keyed, so the
+ * same `sourceSession@ceiling` reuses its numbers — archive.ts depends on it).
+ *
+ * Numbering is per-author-session (invariant: chapters keyed by creating
+ * session, so siblings cannot collide), and the flat index is built by the
+ * PLUGIN walking the ancestor path — the model never traverses a graph.
+ */
+import type { ChapterRecord } from './archive.ts';
+import type { CollectionSignature } from './signature.ts';
+export interface SessionState {
+    /** Registry-level parent, set at continuation commit. null until linked. */
+    parentSession: string | null;
+    /** Root of the ancestry tree; the store directory key. Self for a root session. */
+    rootSession: string;
+    /** Next unallocated chapter number for THIS author session. */
+    nextChapterNumber: number;
+    chapters: ChapterRecord[];
+    /** attemptKey -> numbers, so an idempotent retry reuses rather than duplicates. */
+    reservations: Record<string, number[]>;
+    /**
+     * compactionId -> the plan summarize() committed to: the TOC text already
+     * cited `path`, so finalize (possibly after a crash and process restart)
+     * must reproduce it exactly. Rebuilding the title from messages is not
+     * available post-commit — this manifest is the durable bridge.
+     */
+    plans: Record<string, {
+        number: number;
+        path: string;
+        title: string;
+        summary: string;
+        chapters?: PlanChapter[] | undefined;
+    }>;
+    /**
+     * compactionId -> chapter numbers, written when a compaction's chapter bodies
+     * are durably finalized post-commit. Idempotence key for the finalizer and
+     * the reconciliation scan (FINDINGS § correlation seam).
+     */
+    finalized: Record<string, number[]>;
+    /**
+     * Per-turn deterministic signatures, appended at turn/end (knowledge-repo
+     * §4.1). The composer (§4.2) reads these at archive time; P2 enrichment may
+     * relabel later but never rewrites them. Append-only like chapters.
+     */
+    collections: CollectionSignature[];
+}
+export declare const freshSession: (sessionId: string) => SessionState;
+/**
+ * One composed chapter of a compaction plan (r29): the composer's range,
+ * its reserved number and cited path, durable BEFORE the summary text cites
+ * them. Legacy single-chapter plans keep the four flat fields and omit this.
+ */
+export interface PlanChapter {
+    number: number;
+    path: string;
+    title: string;
+    summary: string;
+    startSeq: number;
+    endSeq: number;
+}
+/** Persist a summarize-time plan so finalization survives a restart. */
+export declare function rememberPlan(state: SessionState, compactionId: string, plan: {
+    number: number;
+    path: string;
+    title: string;
+    summary: string;
+    chapters?: PlanChapter[];
+}): SessionState;
+/** Record a post-commit finalization for one compaction. Same write twice is a no-op. */
+export declare function markFinalized(state: SessionState, compactionId: string, numbers: readonly number[]): SessionState;
+/** True when a compaction's chapters are already committed (finalizer + scan use this). */
+export declare const isFinalized: (state: SessionState, compactionId: string) => boolean;
+/** Immutably updated copy with `n` numbers reserved for `attemptId`. */
+export declare function reserve(state: SessionState, attemptId: string, count: number): {
+    state: SessionState;
+    numbers: number[];
+};
+/** Append verified chapter records. A record with an existing (number) identity is a no-op — retries are safe. */
+export declare function appendChapters(state: SessionState, records: readonly ChapterRecord[]): SessionState;
+/**
+ * Commit point for a continuation: the child inherits the PARENT's root and
+ * gets its direct parent recorded. Set once, never rewritten — re-pointing a
+ * linked session would silently re-home every chapter below it. Same link
+ * twice is a no-op (retry safety); a DIFFERENT link is corruption or a bug,
+ * and it throws.
+ */
+export declare function linkChild(state: SessionState, parentSessionId: string, parentRootSession: string): SessionState;
+/**
+ * Walk parent links root-first. Throws on a cycle or a missing parent — both
+ * are registry corruption, and an infinite walk is how a small bad write
+ * becomes a hung plugin at the worst moment.
+ */
+export declare function ancestorPath(get: (id: string) => SessionState | undefined, sessionId: string, maxDepth?: number): string[];
+export interface IndexEntry {
+    /** Session that authored the chapter, for back-links. */
+    authorSession: string;
+    number: number;
+    path: string;
+    title: string;
+    summary: string;
+    /** Integrity verdict supplied by the caller (verifyChapter via its fs port). */
+    status: 'ok' | 'modified' | 'missing';
+}
+/**
+ * The flat, chronological, numbered index the TOC renders — reading order IS
+ * causal order (docs/architecture.md § Ancestry). Ancestor sessions first;
+ * within a session, by reserved number. Siblings are excluded by construction:
+ * the walk never enters them.
+ */
+export declare function buildIndex(path: readonly string[], get: (id: string) => SessionState | undefined, status: (record: ChapterRecord) => IndexEntry['status']): IndexEntry[];
+/** Append one turn's signature. Idempotent per turn (same seqs → no-op), like appendChapters. */
+export declare function appendCollection(state: SessionState, sig: CollectionSignature): SessionState;

package/lib/registry.js

@@ -0,0 +1,130 @@
+export const freshSession = (sessionId) => ({
+    parentSession: null,
+    rootSession: sessionId,
+    nextChapterNumber: 1,
+    collections: [],
+    chapters: [],
+    reservations: {},
+    plans: {},
+    finalized: {},
+});
+/** Persist a summarize-time plan so finalization survives a restart. */
+export function rememberPlan(state, compactionId, plan) {
+    return { ...state, plans: { ...state.plans, [compactionId]: plan } };
+}
+/** Record a post-commit finalization for one compaction. Same write twice is a no-op. */
+export function markFinalized(state, compactionId, numbers) {
+    if (state.finalized[compactionId] !== undefined)
+        return state;
+    return { ...state, finalized: { ...state.finalized, [compactionId]: [...numbers] } };
+}
+/** True when a compaction's chapters are already committed (finalizer + scan use this). */
+export const isFinalized = (state, compactionId) => state.finalized[compactionId] !== undefined;
+/** Immutably updated copy with `n` numbers reserved for `attemptId`. */
+export function reserve(state, attemptId, count) {
+    if (count <= 0 || !Number.isInteger(count)) {
+        throw new Error(`reserve: count must be a positive integer, got ${count}`);
+    }
+    const existing = state.reservations[attemptId];
+    if (existing !== undefined) {
+        if (existing.length !== count) {
+            // Same attempt, different size: the caller's chapter set changed under a
+            // half-finished attempt. Reusing a shorter list would silently drop
+            // chapters; growing would collide. Refuse — never guess.
+            throw new Error(`reserve: attempt "${attemptId}" already holds ${existing.length} numbers, requested ${count}`);
+        }
+        return { state, numbers: [...existing] };
+    }
+    const numbers = Array.from({ length: count }, (_, i) => state.nextChapterNumber + i);
+    return {
+        state: {
+            ...state,
+            nextChapterNumber: state.nextChapterNumber + count,
+            reservations: { ...state.reservations, [attemptId]: numbers },
+        },
+        numbers,
+    };
+}
+/** Append verified chapter records. A record with an existing (number) identity is a no-op — retries are safe. */
+export function appendChapters(state, records) {
+    const known = new Set(state.chapters.map((c) => c.number));
+    const fresh = records.filter((r) => !known.has(r.number));
+    if (fresh.length === 0)
+        return state;
+    return { ...state, chapters: [...state.chapters, ...fresh] };
+}
+/**
+ * Commit point for a continuation: the child inherits the PARENT's root and
+ * gets its direct parent recorded. Set once, never rewritten — re-pointing a
+ * linked session would silently re-home every chapter below it. Same link
+ * twice is a no-op (retry safety); a DIFFERENT link is corruption or a bug,
+ * and it throws.
+ */
+export function linkChild(state, parentSessionId, parentRootSession) {
+    if (state.parentSession !== null) {
+        if (state.parentSession === parentSessionId && state.rootSession === parentRootSession)
+            return state;
+        throw new Error(`linkChild: session already linked to parent ${state.parentSession} (root ${state.rootSession});`
+            + ` refusing rewrite to parent ${parentSessionId} (root ${parentRootSession})`);
+    }
+    return { ...state, parentSession: parentSessionId, rootSession: parentRootSession };
+}
+/**
+ * Walk parent links root-first. Throws on a cycle or a missing parent — both
+ * are registry corruption, and an infinite walk is how a small bad write
+ * becomes a hung plugin at the worst moment.
+ */
+export function ancestorPath(get, sessionId, maxDepth = 1000) {
+    const path = [];
+    const seen = new Set();
+    let cursor = sessionId;
+    while (cursor !== undefined) {
+        if (seen.has(cursor))
+            throw new Error(`ancestorPath: cycle through ${cursor}`);
+        if (seen.size >= maxDepth)
+            throw new Error(`ancestorPath: exceeded depth ${maxDepth}`);
+        seen.add(cursor);
+        const state = get(cursor);
+        if (state === undefined) {
+            if (cursor === sessionId)
+                return [cursor]; // unregistered root: itself is the path
+            throw new Error(`ancestorPath: missing state for parent ${cursor} (registry corruption)`);
+        }
+        path.unshift(cursor);
+        cursor = state.parentSession ?? undefined;
+    }
+    return path;
+}
+/**
+ * The flat, chronological, numbered index the TOC renders — reading order IS
+ * causal order (docs/architecture.md § Ancestry). Ancestor sessions first;
+ * within a session, by reserved number. Siblings are excluded by construction:
+ * the walk never enters them.
+ */
+export function buildIndex(path, get, status) {
+    const entries = [];
+    for (const sessionId of path) {
+        const state = get(sessionId);
+        if (state === undefined)
+            continue;
+        for (const chapter of [...state.chapters].sort((a, b) => a.number - b.number)) {
+            entries.push({
+                authorSession: sessionId,
+                number: chapter.number,
+                path: chapter.path,
+                title: chapter.title,
+                summary: chapter.summary,
+                status: status(chapter),
+            });
+        }
+    }
+    return entries;
+}
+/** Append one turn's signature. Idempotent per turn (same seqs → no-op), like appendChapters. */
+export function appendCollection(state, sig) {
+    const last = state.collections[state.collections.length - 1];
+    if (last !== undefined && last.seqs.length === sig.seqs.length && last.seqs.every((q, i) => q === sig.seqs[i]))
+        return state;
+    return { ...state, collections: [...state.collections, sig] };
+}
+//# sourceMappingURL=registry.js.map

package/lib/registry.js.map

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

package/lib/render.d.ts

@@ -0,0 +1,40 @@
+import type { ArtifactRef, ChapterRange, RenderConfig, RenderedChapter, SessionEventLike, ToolResultCandidate, ToolResultOverride } from './types.ts';
+/** chars/4 until the host tokenMeter is wired in. Labelled an estimate everywhere it surfaces. */
+export declare const estimateTokens: (text: string) => number;
+/**
+ * A fence strictly longer than any backtick run inside `body`, so embedded code blocks cannot close it.
+ * Markdown requires the closing fence to be at least as long as the opening one.
+ */
+export declare function longerFence(body: string): string;
+/** Wrapped in a fence long enough to survive any content, including nested fences. */
+export declare function fenced(content: string, info?: string): string;
+export declare const sha256: (text: string) => string;
+/** `artifacts/8f/8f3a1c9d….txt` — sharded so one directory never holds the whole subtree. */
+export declare const artifactPath: (hash: string) => string;
+export declare function artifactRef(text: string, opts: {
+    toolName: string;
+    sourceSeq: number;
+    inlined: boolean;
+}): ArtifactRef;
+/**
+ * Validate model-supplied ranges. Never trust them (hard rule): an overlap duplicates archived text and a
+ * gap silently drops history, so both are errors here rather than data that quietly goes missing.
+ */
+export declare function validateRanges(chapters: ChapterRange[], archiveCeiling: number): ChapterRange[];
+/** Enumerate tool results in a range so the model can decide keep/defer against real sizes. */
+export declare function toolResultCandidates(events: SessionEventLike[], range: ChapterRange): ToolResultCandidate[];
+/**
+ * Render one chapter. `overrides` is the model's sparse exception list; anything not named follows the
+ * default rule (small results inline, large ones deferred). Either way the artifact is written, so a wrong
+ * call costs a `read` and never loses data.
+ */
+export declare function renderChapter(events: SessionEventLike[], range: ChapterRange, config: RenderConfig, overrides?: readonly ToolResultOverride[], topics?: readonly string[]): RenderedChapter;
+/**
+ * The cumulative index that replaces compacted history. Built from registry records, never from an LLM —
+ * which is the entire latency argument: no summarization call, no tokens, no paraphrase.
+ */
+export declare function renderIndex(entries: readonly {
+    path: string;
+    title: string;
+    summary: string;
+}[]): string;