@fractalsynapse/dsh-chapters 0.0.0-stage → 0.2.20

package/lib/session-rules.d.ts

@@ -0,0 +1,222 @@
+import { type RuleRecord, type RulesSectionResult } from './rules.ts';
+import type { SessionEventLike } from './types.ts';
+/** One captured rule: the human's body, anchored to the seq it came from. */
+export interface CapturedRule {
+    body: string;
+    seq: number;
+}
+/**
+ * The markers a turn's HUMAN messages contain. Two screens, both load-bearing:
+ *
+ *   - `isHumanAuthored` — the same shared predicate signatures use (r28: injected
+ *     context moves chapter boundaries and would here too). A host-injected
+ *     instruction file that happens to contain a line starting with the marker is
+ *     NOT a rule request.
+ *   - `stripReminderSpans` — `<system-reminder>` spans ride INSIDE human
+ *     messages. The human's own lines survive; the injected span does not (§15
+ *     amendment, "host-injected context is not conversation").
+ */
+export declare function humanRuleMarkers(events: readonly SessionEventLike[], prefix: string): CapturedRule[];
+/**
+ * The next free number in the SHARED per-machine sequence. Both tiers author
+ * into `rules/<harness>/`, and ids are `<harness>/<NNN>`, so a session rule must
+ * not take a number a project rule already holds — neither the registry's (pre-
+ * sync) records' nor the disk's (a killed write leaves a file without a record;
+ * the r39 walk-past rule). Numbers are allocated, never scanned-for-content.
+ */
+export declare function nextRuleNumber(opts: {
+    records: Iterable<[string, RuleRecord]>;
+    harnessId: string;
+    rulesDir: string;
+}): number;
+export interface CaptureDeps {
+    /** workspace store root, e.g. `<cwd>/.dsh-chapters` */
+    storeDir: string;
+    harnessId: string;
+    /** the session whose tree these rules bind (§7.5 activation) */
+    sessionId: string;
+    /** for id-collision avoidance with the shared tier's pre-sync records */
+    records: Iterable<[string, RuleRecord]>;
+    prefix: string;
+    /** the completed turn's events */
+    events: readonly SessionEventLike[];
+    now?: () => string;
+}
+export interface CaptureResult {
+    written: string[];
+    skipped: number;
+}
+/**
+ * Capture this turn's markers. Returns the rule ids written (empty when nothing
+ * matched), and never throws into the session — the caller contains failures the
+ * way the signature listener does.
+ */
+export declare function captureSessionRules(deps: CaptureDeps): CaptureResult;
+/**
+ * The current session's ancestor path, root-first — the async mirror of
+ * `registry.ancestorPath`, which takes a synchronous getter the realm does not
+ * have. §7.5 activation is "this rule's session is on MY path", so every render
+ * site needs this walk; a missing parent stops the walk instead of throwing,
+ * because a rules render must never break a compaction (the same containment
+ * the notice path uses).
+ */
+export declare function ancestorSessionIds(get: (id: string) => Promise<{
+    parentSession: string | null;
+} | undefined>, sessionId: string, maxDepth?: number): Promise<string[]>;
+/** One mined rule candidate, as the enrichment pass proposes it (§7.5). */
+/**
+ * Rule ancestry crosses BOTH lineage edges (#52, user decision 2026-10-21).
+ *
+ * Our registry is the sole authority on CONTINUATION lineage and deliberately
+ * ignores the kernel header's `parentSession` — right for chapter numbering and
+ * the TOC, and it left a whole session shape uncovered: a delegated subagent is an
+ * unrelated root by that view, so it inherited no activated rules from ANY door.
+ * The rule tier now walks both edges, READ-ONLY, writing nothing:
+ *
+ *   registry parentSession (ours)  ∪  header parentSession (the host's)
+ *
+ * transitively, so a subagent of a continuation child of a delegating parent sees
+ * the whole chain — and still walks UP only, which keeps the direction one-way: a
+ * child's inferences never govern the session that delegated them. Two bounds,
+ * because this runs inside a head rebuild: an expansion cap, and a reader that
+ * throws contributes no edge — a rule walk must never break a turn.
+ */
+export declare const RULE_LINEAGE_MAX_EXPANSIONS = 64;
+export interface RuleAncestryWalk {
+    ancestors: Set<string>;
+    truncated: boolean;
+}
+export declare function ruleAncestorSet(opts: {
+    /** Usually [sessionId]; the session always belongs to its own ancestry. */
+    seeds: readonly string[];
+    /** Our registry chain (continuation lineage). */
+    registryAncestors?: ((id: string) => Promise<readonly string[]>) | undefined;
+    /** The host header's delegation edge, for any session id. */
+    parentOf?: ((id: string) => Promise<string | null | undefined>) | undefined;
+    maxExpansions?: number;
+}): Promise<RuleAncestryWalk>;
+/**
+ * A `parentOf` from whatever session views this plane can reach: a live agent
+ * handle first, then `sessionQuery`'s durable headers. undefined when NEITHER
+ * exists — which degrades the walk to registry edges only.
+ *
+ * Cordis `ctx.get` THROWS for an unregistered service and a plugin plane may have
+ * neither, so every lookup is guarded (the #43 lesson: a strict host makes a
+ * plausible service name throw).
+ */
+export declare function makeHeaderParentReader(get?: (name: string) => unknown): ((id: string) => Promise<string | null | undefined>) | undefined;
+export interface MinedRule {
+    text: string;
+    category: string;
+    /** the human's own words this rule came from — the quote IS the gate */
+    quote: string;
+}
+/**
+ * THE verbatim-quote gate (§7.5). A mined rule activates only when its quote is
+ * the human's own words, present verbatim (whitespace-normalized) in the
+ * chapter's USER text. Assistant prose is deliberately NOT admissible evidence:
+ * the model restating an instruction it was given is the amplification path, and
+ * a quote it invented is a guess wearing a citation.
+ */
+export declare function quoteIsHuman(humanText: string, quote: string): boolean;
+export interface MineDeps {
+    storeDir: string;
+    harnessId: string;
+    /** the session whose tree the mined rules bind — the chapter's OWN session */
+    sessionId: string;
+    records: Iterable<[string, RuleRecord]>;
+    /** the chapter's human-authored bytes (its `**User…:**` chunks joined) */
+    humanText: string;
+    rules: readonly MinedRule[];
+    /** per-chapter cap: one conversation must not mint a dozen standing orders */
+    maxPerChapter: number;
+    /** the chapter these came from (provenance rendered into the head) */
+    chapterNumber: number;
+    /**
+     * §7.5 policy (amended 2026-10-21): may a mined rule govern on arrival? TRUE by
+     * default — a rule the model inferred from context is the reason this tier
+     * exists; the human may not have known to say it. When false every mined rule is
+     * written `reviewOnly: true` and stays inert until this machine approves it, the
+     * conservative posture a shared box may want.
+     */
+    autoActivate: boolean;
+    now?: () => string;
+}
+/**
+ * Write the mined candidates. Each records its warrant (`stated` / `inferred`) and
+ * the chapter it came from; whether it governs on arrival is the `autoActivate`
+ * POLICY, not an evidence test (§7.5, amended 2026-10-21 — the tier's premise is
+ * that the human may not have known to say the rule). Deduped by normalized body
+ * against what the machine already holds, so re-running the ladder (or a
+ * chapter annotated by a newer model) fills gaps and never duplicates.
+ */
+export declare function captureMinedRules(deps: MineDeps): {
+    ids: string[];
+    stated: number;
+    inferred: number;
+    pending: number;
+};
+/** Turn a task description into the relevance term set §7.4 selects on — the same
+ * normalization the rule-term index uses, so a query and a rule body meet in one
+ * vocabulary instead of two. */
+export declare function queryTopics(query: string): string[];
+/** The registry view the renderer needs — kept structural so tests can hand it a map. */
+export interface RulesStoreLike {
+    get(id: string): Promise<{
+        parentSession: string | null;
+        collections: {
+            terms: string[];
+        }[];
+    } | undefined>;
+}
+export interface RenderRulesOpts {
+    mirrorDir: string;
+    storeDir: string;
+    projectKey: string;
+    harnessId: string;
+    budgetTokens: number;
+    projectCap?: number | undefined;
+    sessionCap?: number | undefined;
+    /** §7.4 relevance on; off ⇒ deterministic category→id order (the tape order). */
+    relevance: boolean;
+    /** §7.6: a BRANCH head carries the project tier only — zero session bytes. */
+    includeSession: boolean;
+    /** When supplied, selection uses THESE terms (the assembly door passes the
+     * task query) instead of the session's own recent signatures. */
+    topicsOverride?: readonly string[] | undefined;
+    store: RulesStoreLike;
+    sessionId: string;
+    /** #52: reads the host header's parentSession for any id in the chain. Absent
+     * ⇒ the walk follows registry edges only, so delegation contributes nothing. */
+    parentOf?: ((id: string) => Promise<string | null | undefined>) | undefined;
+}
+/**
+ * THE one rules renderer for a rebuilt head. Both doors (continue / fork) and the
+ * compaction checkpoint call this and nothing else, so the same session can never
+ * see two different rule sets depending on which path rebuilt its head — the same
+ * one-builder discipline as `search.rankEntries` and `deterministicCommand`.
+ *
+ * Relevance topics come from the session’s OWN stored turn signatures:
+ * deterministic, already on disk, zero model tokens (§1 invariant 1).
+ */
+export declare function renderRulesBlock(opts: RenderRulesOpts): Promise<RulesSectionResult>;
+/**
+ * The `turn/end` listener (the same boundary the topic signatures collect on —
+ * §7.5: this extends the existing door, it is not a sixth archive moment).
+ *
+ * Never-break containment: every failure lands in `warn`, because a rule that
+ * could not be written must not cost a user their turn.
+ */
+export declare function makeRuleCaptureListener(deps: {
+    enabled: () => boolean;
+    prefix: () => string;
+    harnessId: () => string;
+    storeRoot: (cwd: string) => string;
+    store: () => Promise<{
+        store: {
+            rules(): IterableIterator<[string, RuleRecord]>;
+        };
+    }>;
+    warn: (error: unknown) => void;
+    onCaptured?: (sessionId: string, ids: string[]) => void;
+}): (session: unknown, event: unknown) => void;

package/lib/session-rules.js

@@ -0,0 +1,454 @@
+/**
+ * #50 §7.5 — the session tier's capture path.
+ *
+ * Two speeds, deliberately (this is §6.2's single-slot constraint applied to
+ * rules, not a new policy):
+ *
+ *   - **marker**: `ADD RULE: <text>` on a line of a HUMAN message becomes an
+ *     active session rule at the existing `turn/end` boundary — deterministic,
+ *     zero model tokens (§1 invariant 1), the body is the human's own words.
+ *   - **enrichment** (src/enrich-wire.ts): idle-batched, default off, and only
+ *     ever activates behind a verbatim quote of human bytes.
+ *
+ * Session rules are **files, not registry rows**: their activation derives from
+ * the ancestor path (§7.5), so they need no record to resolve status, no linked
+ * project (an unlinked checkout still gets its rules — the whole point of the
+ * tier), and no fact in a pool-synced curation file. The registry keeps holding
+ * the shared tier's pre-sync records exactly as before.
+ *
+ * Idempotent by body: repeated `turn/end`s on a continuable child, and the
+ * after-loss re-derivation walk over the durable log, both FILL GAPS and never
+ * duplicate — the same posture `rehydrateStoreFromMirror` takes.
+ *
+ * Pure module: events and paths in, files out. The engine listener mounts it.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { isHumanAuthored, stripReminderSpans } from "./injections.js";
+import { turnSpanOf } from "./signature.js";
+import { buildRulesSection, collectStoreRules, parseRuleFile, parseRuleMarkers, renderRuleFile, ruleSlug, } from "./rules.js";
+import { redactText } from "./redact.js";
+const messageText = (data) => {
+    const message = (data.message ?? data);
+    const content = Array.isArray(message.content) ? message.content : [];
+    return content.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('\n');
+};
+/**
+ * The markers a turn's HUMAN messages contain. Two screens, both load-bearing:
+ *
+ *   - `isHumanAuthored` — the same shared predicate signatures use (r28: injected
+ *     context moves chapter boundaries and would here too). A host-injected
+ *     instruction file that happens to contain a line starting with the marker is
+ *     NOT a rule request.
+ *   - `stripReminderSpans` — `<system-reminder>` spans ride INSIDE human
+ *     messages. The human's own lines survive; the injected span does not (§15
+ *     amendment, "host-injected context is not conversation").
+ */
+export function humanRuleMarkers(events, prefix) {
+    const out = [];
+    const seen = new Set();
+    for (const ev of events) {
+        if (ev.type !== 'user/message')
+            continue;
+        const data = (ev.data ?? {});
+        if (!isHumanAuthored(data))
+            continue;
+        const text = stripReminderSpans(messageText(data)).text;
+        for (const body of parseRuleMarkers(text, prefix)) {
+            if (seen.has(body))
+                continue;
+            seen.add(body);
+            out.push({ body, seq: ev.seq });
+        }
+    }
+    return out;
+}
+/**
+ * The next free number in the SHARED per-machine sequence. Both tiers author
+ * into `rules/<harness>/`, and ids are `<harness>/<NNN>`, so a session rule must
+ * not take a number a project rule already holds — neither the registry's (pre-
+ * sync) records' nor the disk's (a killed write leaves a file without a record;
+ * the r39 walk-past rule). Numbers are allocated, never scanned-for-content.
+ */
+export function nextRuleNumber(opts) {
+    const used = new Set();
+    const tail = new RegExp(`^${opts.harnessId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/(\\d{3})$`);
+    for (const [id] of opts.records) {
+        const m = tail.exec(id);
+        if (m !== null)
+            used.add(Number(m[1]));
+    }
+    if (fs.existsSync(opts.rulesDir)) {
+        for (const f of fs.readdirSync(opts.rulesDir)) {
+            const m = /^(\d{3})-/.exec(f);
+            if (m !== null)
+                used.add(Number(m[1]));
+        }
+    }
+    let n = 1;
+    while (used.has(n))
+        n += 1;
+    return n;
+}
+const norm = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+/**
+ * Capture this turn's markers. Returns the rule ids written (empty when nothing
+ * matched), and never throws into the session — the caller contains failures the
+ * way the signature listener does.
+ */
+export function captureSessionRules(deps) {
+    const markers = humanRuleMarkers(deps.events, deps.prefix);
+    if (markers.length === 0)
+        return { written: [], skipped: 0 };
+    const rulesDir = path.join(deps.storeDir, 'rules', deps.harnessId);
+    // dedupe against what is ALREADY on disk for this machine (§7.5 idempotence):
+    // a body captured last turn is not captured twice, and a re-derivation pass
+    // over the log fills only the gaps.
+    const existing = new Set();
+    if (fs.existsSync(rulesDir)) {
+        for (const f of fs.readdirSync(rulesDir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            // the SAME parser the collectors use — one definition of a rule body,
+            // never a second hand-rolled frontmatter split that can drift from it.
+            const parsed = parseRuleFile(fs.readFileSync(path.join(rulesDir, f), 'utf8'));
+            if (parsed !== null)
+                existing.add(norm(parsed.body));
+        }
+    }
+    let written = 0;
+    const ids = [];
+    for (const m of markers) {
+        if (existing.has(norm(m.body)))
+            continue;
+        // §9 applies to rule bodies like any other archived bytes: a captured rule
+        // can carry a credential, and this tier is local but still a file on disk.
+        const body = redactText(m.body).text;
+        const number = nextRuleNumber({ records: deps.records, harnessId: deps.harnessId, rulesDir });
+        const title = body.split(/[.!?\n]/)[0].trim().slice(0, 60);
+        const name = `${String(number).padStart(3, '0')}-${ruleSlug('general', title)}.md`;
+        fs.mkdirSync(rulesDir, { recursive: true });
+        const file = path.join(rulesDir, name);
+        // write-once: the file is created complete, never edited in place (§1.3)
+        fs.writeFileSync(file, renderRuleFile({
+            number,
+            category: 'general',
+            title,
+            sourceSession: deps.sessionId,
+            at: (deps.now !== undefined ? deps.now() : new Date().toISOString()),
+            body: `${body}\n`,
+            scope: 'session',
+            session: deps.sessionId,
+            derivedFrom: 'marker',
+        }), { flag: 'wx' });
+        ids.push(`${deps.harnessId}/${String(number).padStart(3, '0')}`);
+        existing.add(norm(body));
+        written += 1;
+    }
+    return { written: ids, skipped: markers.length - written };
+}
+/**
+ * The current session's ancestor path, root-first — the async mirror of
+ * `registry.ancestorPath`, which takes a synchronous getter the realm does not
+ * have. §7.5 activation is "this rule's session is on MY path", so every render
+ * site needs this walk; a missing parent stops the walk instead of throwing,
+ * because a rules render must never break a compaction (the same containment
+ * the notice path uses).
+ */
+export async function ancestorSessionIds(get, sessionId, maxDepth = 1000) {
+    const out = [];
+    const seen = new Set();
+    let cursor = sessionId;
+    while (cursor !== undefined && !seen.has(cursor) && seen.size < maxDepth) {
+        seen.add(cursor);
+        out.push(cursor);
+        const state = await get(cursor);
+        if (state === undefined)
+            break;
+        cursor = state.parentSession ?? undefined;
+    }
+    return out.reverse();
+}
+/** One mined rule candidate, as the enrichment pass proposes it (§7.5). */
+/**
+ * Rule ancestry crosses BOTH lineage edges (#52, user decision 2026-10-21).
+ *
+ * Our registry is the sole authority on CONTINUATION lineage and deliberately
+ * ignores the kernel header's `parentSession` — right for chapter numbering and
+ * the TOC, and it left a whole session shape uncovered: a delegated subagent is an
+ * unrelated root by that view, so it inherited no activated rules from ANY door.
+ * The rule tier now walks both edges, READ-ONLY, writing nothing:
+ *
+ *   registry parentSession (ours)  ∪  header parentSession (the host's)
+ *
+ * transitively, so a subagent of a continuation child of a delegating parent sees
+ * the whole chain — and still walks UP only, which keeps the direction one-way: a
+ * child's inferences never govern the session that delegated them. Two bounds,
+ * because this runs inside a head rebuild: an expansion cap, and a reader that
+ * throws contributes no edge — a rule walk must never break a turn.
+ */
+export const RULE_LINEAGE_MAX_EXPANSIONS = 64;
+export async function ruleAncestorSet(opts) {
+    const cap = opts.maxExpansions ?? RULE_LINEAGE_MAX_EXPANSIONS;
+    const ancestors = new Set();
+    for (const s of opts.seeds)
+        if (s !== '')
+            ancestors.add(s);
+    const queue = [...ancestors];
+    let expansions = 0;
+    let truncated = false;
+    while (queue.length > 0) {
+        if (expansions >= cap) {
+            truncated = true;
+            break;
+        }
+        const id = queue.shift();
+        expansions += 1;
+        const edges = [];
+        if (opts.parentOf !== undefined) {
+            try {
+                const p = await opts.parentOf(id);
+                if (typeof p === 'string' && p !== '')
+                    edges.push(p);
+            }
+            catch { /* unreadable header ⇒ not an ancestor */ }
+        }
+        if (opts.registryAncestors !== undefined) {
+            try {
+                edges.push(...(await opts.registryAncestors(id)));
+            }
+            catch { /* shrink, never fail */ }
+        }
+        for (const e of edges)
+            if (e !== '' && !ancestors.has(e)) {
+                ancestors.add(e);
+                queue.push(e);
+            }
+    }
+    return { ancestors, truncated };
+}
+/**
+ * A `parentOf` from whatever session views this plane can reach: a live agent
+ * handle first, then `sessionQuery`'s durable headers. undefined when NEITHER
+ * exists — which degrades the walk to registry edges only.
+ *
+ * Cordis `ctx.get` THROWS for an unregistered service and a plugin plane may have
+ * neither, so every lookup is guarded (the #43 lesson: a strict host makes a
+ * plausible service name throw).
+ */
+export function makeHeaderParentReader(get) {
+    if (get === undefined)
+        return undefined;
+    // `agents` is a SERVICE: ctx.get('agents').get(id) hands back the live handle —
+    // the same two-step auto-save uses, and the only way to read a session other
+    // than the one currently rendering.
+    const liveParent = (id) => {
+        try {
+            const svc = get('agents');
+            const handle = svc?.get?.(id);
+            const session = handle?.agent?.session ?? handle?.session;
+            const p = session?.header?.parentSession;
+            return typeof p === 'string' && p !== '' ? p : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    let durable = null;
+    const durableParent = async (id) => {
+        if (durable === null) {
+            try {
+                const sq = get('sessionQuery');
+                if (sq?.listSessions === undefined)
+                    return null;
+                const m = new Map();
+                for (const r of await sq.listSessions() ?? []) {
+                    const sid = r?.header?.id;
+                    if (typeof sid === 'string' && sid !== '') {
+                        const p = r.header?.parentSession;
+                        m.set(sid, typeof p === 'string' && p !== '' ? p : null);
+                    }
+                }
+                durable = m;
+            }
+            catch {
+                return null;
+            }
+        }
+        return durable.get(id) ?? null;
+    };
+    return async (id) => {
+        // live handle first: it is the current session's own edge, and the freshest
+        // answer for any session still open in this process
+        const live = liveParent(id);
+        if (live !== null)
+            return live;
+        return durableParent(id);
+    };
+}
+const normQuote = (t) => t.toLowerCase().replace(/\s+/g, ' ').replace(/[\u2018\u2019]/g, "'").replace(/[\u201c\u201d]/g, '"').trim();
+/**
+ * THE verbatim-quote gate (§7.5). A mined rule activates only when its quote is
+ * the human's own words, present verbatim (whitespace-normalized) in the
+ * chapter's USER text. Assistant prose is deliberately NOT admissible evidence:
+ * the model restating an instruction it was given is the amplification path, and
+ * a quote it invented is a guess wearing a citation.
+ */
+export function quoteIsHuman(humanText, quote) {
+    const q = normQuote(quote);
+    if (q.length < 3)
+        return false;
+    return normQuote(humanText).includes(q);
+}
+/**
+ * Write the mined candidates. Each records its warrant (`stated` / `inferred`) and
+ * the chapter it came from; whether it governs on arrival is the `autoActivate`
+ * POLICY, not an evidence test (§7.5, amended 2026-10-21 — the tier's premise is
+ * that the human may not have known to say the rule). Deduped by normalized body
+ * against what the machine already holds, so re-running the ladder (or a
+ * chapter annotated by a newer model) fills gaps and never duplicates.
+ */
+export function captureMinedRules(deps) {
+    const rulesDir = path.join(deps.storeDir, 'rules', deps.harnessId);
+    const existing = new Set();
+    for (const r of collectStoreRules(deps.storeDir, deps.harnessId))
+        existing.add(norm(r.body));
+    const written = [];
+    let stated = 0;
+    let inferred = 0;
+    let pending = 0;
+    const cap = Math.max(0, deps.maxPerChapter);
+    for (const m of deps.rules) {
+        // the cap counts rules WRITTEN, not candidates examined: a duplicate or an
+        // over-short candidate must not eat a chapter's budget
+        if (written.length >= cap)
+            break;
+        const body = redactText(m.text.trim().replace(/\s+/g, ' ')).text;
+        if (body.length < 10 || existing.has(norm(body)))
+            continue;
+        // The quote check CLASSIFIES, it does not authorize (§7.5, amended
+        // 2026-10-21): `stated` = a human sentence is behind this, `inferred` = the
+        // model judged it useful and nobody said it. Both govern unless the plugin is
+        // configured to hold mined rules for review, and the difference is SHOWN in
+        // the rendered rule line — which is where a judgement call belongs.
+        const basis = quoteIsHuman(deps.humanText, m.quote) ? 'stated' : 'inferred';
+        const reviewOnly = !deps.autoActivate;
+        const number = nextRuleNumber({ records: deps.records, harnessId: deps.harnessId, rulesDir });
+        const category = (m.category || 'general').toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 24) || 'general';
+        const title = body.split(/[.!?]/)[0].trim().slice(0, 60);
+        const name = `${String(number).padStart(3, '0')}-${ruleSlug(category, title)}.md`;
+        fs.mkdirSync(rulesDir, { recursive: true });
+        fs.writeFileSync(path.join(rulesDir, name), renderRuleFile({
+            number, category, title, sourceSession: deps.sessionId,
+            at: (deps.now !== undefined ? deps.now() : new Date().toISOString()),
+            body: `${body}\n`,
+            scope: 'session', session: deps.sessionId, derivedFrom: 'model',
+            reviewOnly, basis, chapter: deps.chapterNumber,
+        }), { flag: 'wx' });
+        written.push(`${deps.harnessId}/${String(number).padStart(3, '0')}`);
+        existing.add(norm(body));
+        if (basis === 'stated')
+            stated += 1;
+        else
+            inferred += 1;
+        if (reviewOnly)
+            pending += 1;
+    }
+    return { ids: written, stated, inferred, pending };
+}
+/** Turn a task description into the relevance term set §7.4 selects on — the same
+ * normalization the rule-term index uses, so a query and a rule body meet in one
+ * vocabulary instead of two. */
+export function queryTopics(query) {
+    const out = [];
+    for (const tok of query.toLowerCase().split(/[^a-z0-9]+/)) {
+        if (tok.length < 3 || tok.length > 28 || out.includes(tok))
+            continue;
+        out.push(tok);
+    }
+    return out.slice(0, 40);
+}
+/**
+ * THE one rules renderer for a rebuilt head. Both doors (continue / fork) and the
+ * compaction checkpoint call this and nothing else, so the same session can never
+ * see two different rule sets depending on which path rebuilt its head — the same
+ * one-builder discipline as `search.rankEntries` and `deterministicCommand`.
+ *
+ * Relevance topics come from the session’s OWN stored turn signatures:
+ * deterministic, already on disk, zero model tokens (§1 invariant 1).
+ */
+export async function renderRulesBlock(opts) {
+    const walk = opts.includeSession
+        ? await ruleAncestorSet({
+            seeds: [opts.sessionId],
+            registryAncestors: async (id) => await ancestorSessionIds(async (s) => await opts.store.get(s), id),
+            ...(opts.parentOf !== undefined ? { parentOf: opts.parentOf } : {}),
+        })
+        : { ancestors: new Set(), truncated: false };
+    const ancestors = walk.ancestors;
+    const state = opts.relevance ? await opts.store.get(opts.sessionId) : undefined;
+    const topics = opts.topicsOverride !== undefined && opts.topicsOverride.length > 0
+        ? opts.topicsOverride
+        : opts.relevance && state !== undefined
+            ? state.collections.slice(-6).flatMap((c) => c.terms).slice(0, 40)
+            : undefined;
+    return buildRulesSection(opts.mirrorDir, {
+        projectKey: opts.projectKey,
+        harnessId: opts.harnessId,
+        budgetTokens: opts.budgetTokens,
+        projectCap: opts.projectCap,
+        sessionCap: opts.sessionCap,
+        ...(opts.includeSession ? { storeDir: opts.storeDir, ancestorSessions: ancestors } : {}),
+        ...(topics !== undefined ? { relevanceTopics: topics } : {}),
+        ...(walk.truncated ? { lineageTruncated: true } : {}),
+    });
+}
+/**
+ * The `turn/end` listener (the same boundary the topic signatures collect on —
+ * §7.5: this extends the existing door, it is not a sixth archive moment).
+ *
+ * Never-break containment: every failure lands in `warn`, because a rule that
+ * could not be written must not cost a user their turn.
+ */
+export function makeRuleCaptureListener(deps) {
+    const chains = new Map();
+    return (session, event) => {
+        try {
+            if (!deps.enabled())
+                return;
+            if (event?.type !== 'turn/end')
+                return;
+            const id = session?.id;
+            const events = session?.snapshotEvents?.();
+            const cwd = session?.header?.cwd;
+            const endSeq = event.seq;
+            if (id === undefined || events === undefined || cwd === undefined || endSeq === undefined)
+                return;
+            const span = turnSpanOf(events, endSeq);
+            if (span.length === 0)
+                return;
+            // cheap pre-screen OUTSIDE the async chain: no marker in this turn is the
+            // overwhelmingly common case, and it must cost one regex over one message.
+            if (humanRuleMarkers(span, deps.prefix()).length === 0)
+                return;
+            const job = () => deps.store()
+                .then(({ store }) => captureSessionRules({
+                storeDir: deps.storeRoot(cwd),
+                harnessId: deps.harnessId(),
+                sessionId: id,
+                records: store.rules(),
+                prefix: deps.prefix(),
+                events: span,
+            }))
+                .then((res) => { if (res.written.length > 0)
+                deps.onCaptured?.(id, res.written); })
+                .catch(deps.warn);
+            const prev = chains.get(id);
+            void (prev === undefined ? job() : prev.then(job)).finally(() => chains.delete(id));
+        }
+        catch (error) {
+            deps.warn(error);
+        }
+    };
+}
+//# sourceMappingURL=session-rules.js.map