wyrd-scribe 0.1.0

package/dist/lineage.d.ts

@@ -0,0 +1,195 @@
+/**
+ * THE LINEAGE LINE — `wyrd.lineage/v1`. One JSON object per line, LF-terminated, append-only (D3).
+ *
+ * ⚠⚠ EVERY IDENTITY CARRIES AN EXPLICIT DISCRIMINANT AND ITS VAULT, and both halves are rulings
+ * rather than taste (2026-08-31 identity block).
+ *
+ *   · `kind` exists so no consumer ever type-sniffs a string. J35 shipped a POLYMORPHIC SCALAR —
+ *     one field holding a capture id normally and a path for rows that can never have one — and
+ *     the measured cost was that every consumer needed a sniff branch, with ~84 edges hanging on
+ *     one of them being written correctly. Our format is JSONL. A structured format has no reason
+ *     to make a reader guess. A page with no stable id is PERMANENTLY `kind: 'path'`; it is never
+ *     `id: null`, and never a value with an explanatory suffix.
+ *   · `vault_id` exists because `.wyrd/lineage.jsonl` scopes identity IMPLICITLY, and implicit
+ *     scoping survives only while the record stays home. Magi is mage-to-mage, so a record WILL
+ *     travel, and the moment it does a bare path is ambiguous across two granted vaults —
+ *     the same defect the ruling exists to prevent, one layer up. The identity block gave two
+ *     acceptable answers and named picking neither as the failure. This is the first: the identity
+ *     carries its vault explicitly.
+ *
+ * ⚠⚠ THE LIMITS BELOW ARE POLICY BOUNDS, NOT PROVEN ATOMICITY GUARANTEES. B4's argument is that a
+ * single `write` of a complete line under `O_APPEND` does not interleave for writes below a
+ * pipe/PIPE_BUF-class threshold. That threshold is a property of the platform and the filesystem,
+ * it is not 65,536 anywhere in particular, and nothing in this repo has measured it. What these
+ * numbers actually buy is that a line CANNOT grow without bound through a large quote or a long
+ * `derived_from` list — so the atomicity argument is being made about a bounded object rather than
+ * an unbounded one. Calling that a guarantee would be the "confident number with no regime" shape
+ * this lane keeps catching in its own work.
+ */
+import type { ResolvedSpan } from './span.js';
+import type { ScribeRefusal } from './refusal.js';
+export declare const LINEAGE_SCHEMA = "wyrd.lineage/v1";
+/** ≤ 1,024 UTF-8 bytes of quote text retained; the rest is dropped and `truncated` says so. */
+export declare const QUOTE_BYTE_BUDGET = 1024;
+/** At most this many `derived_from` entries per line. */
+export declare const MAX_SOURCES = 64;
+/** At most this many spans per line, summed across all sources. */
+export declare const MAX_SPANS = 256;
+/** The serialised line INCLUDING its terminating LF. */
+export declare const MAX_LINE_BYTES = 65536;
+/**
+ * At most this many UTF-8 bytes in the page path, as the ledger spells it.
+ *
+ * ⚠⚠ IT EXISTS BECAUSE THE PAGE PATH WAS THE ONLY VARIABLE-WIDTH FIELD IN A BOUNDED LINE WITH NO
+ * BOUND OF ITS OWN. Quotes have `QUOTE_BYTE_BUDGET`, sources have `MAX_SOURCES`, spans have
+ * `MAX_SPANS`, the digest is fixed at 64 hex characters and the byte count is bounded by
+ * `Number.MAX_SAFE_INTEGER` — so every other contributor to `MAX_LINE_BYTES` could be reasoned
+ * about in advance, and one could not. A single 60,000-byte path was enough to consume the whole
+ * budget and starve fields the caller had every right to expect would fit.
+ *
+ * ⚠ 4,096 IS THE FENCE'S `MAX_GRANT_LENGTH`, DELIBERATELY. That constant bounds the grant ROOT and
+ * says nothing about the grant-RELATIVE path — measured 2026-09-03, an in-grant path was created
+ * at 16,407 characters with no refusal — so this is not a restatement of an existing guarantee.
+ * Reusing the number keeps one order of magnitude in the reader's head rather than two, and 4,096
+ * bytes of path is far past any real vault while leaving 61,440 bytes for everything else.
+ *
+ * ⚠ WHAT THIS DOES NOT CLOSE. The bound is checked against the path the CALLER asked for, and the
+ * ledger records the path the filesystem RESOLVED to; an in-grant junction can lengthen it after
+ * the page is created. `stamp.ts` step 9 remains the last line of defence for that case and now
+ * reports it honestly. Closing it properly needs a pre-write canonical path from the fence, which
+ * is a change to the Fence's public API and remains outside this module's contract.
+ */
+export declare const MAX_PAGE_PATH_BYTES = 4096;
+export interface PageIdentity {
+    readonly kind: 'path';
+    readonly vault_id: string;
+    readonly path: string;
+}
+export interface ContentHash {
+    readonly algorithm: 'sha256';
+    readonly digest: string;
+    readonly bytes: number;
+}
+export interface StoredQuote {
+    readonly text: string;
+    readonly original_utf8_bytes: number;
+    readonly stored_utf8_bytes: number;
+    readonly sha256: string;
+    readonly truncated: boolean;
+}
+export interface LineageSpan {
+    readonly offset: number;
+    readonly length: number;
+    readonly quote: StoredQuote;
+}
+export interface LineageSource {
+    readonly identity: PageIdentity;
+    readonly content: ContentHash;
+    readonly spans: readonly LineageSpan[];
+}
+export interface LineagePage {
+    readonly identity: PageIdentity;
+    readonly content: ContentHash;
+}
+export interface LineageWriter {
+    readonly server: 'wyrd-scribe';
+    readonly version: string;
+    readonly tool: 'write_page';
+}
+export interface LineageRecord {
+    readonly schema: typeof LINEAGE_SCHEMA;
+    readonly event: 'page_written';
+    /**
+     * ⚠⚠ THE PER-WRITE IDENTIFIER, AND IT EXISTS BECAUSE `recorded_at` IS NOT ONE. Two distinct
+     * writes can produce BYTE-IDENTICAL lines: write a page, delete it outside this server, write
+     * the identical content again within the same millisecond, and every field of the record —
+     * timestamp, page path, digest, sources — is the same. A ledger holding two identical lines
+     * cannot say whether it recorded two events or duplicated one, and that is a question about the
+     * permanent record that nothing else in the line can answer.
+     *
+     * ⚠ SERVER-MINTED, LIKE `recorded_at` AND FOR THE SAME REASON. A caller-supplied id would be an
+     * unauthenticated assertion recorded as fact — the objection that keeps an `actor` field out of
+     * this record entirely.
+     *
+     * ⚠ IT IS AN EVENT ID, NOT A CONTENT HASH. Identical content written twice is TWO events and
+     * gets two ids; that is the distinction the field exists to draw, so deriving it from the
+     * record's own bytes would defeat it exactly where it is needed.
+     */
+    readonly event_id: string;
+    readonly recorded_at: string;
+    readonly writer: LineageWriter;
+    readonly vault: {
+        readonly kind: 'uuid';
+        readonly id: string;
+    };
+    readonly page: LineagePage;
+    readonly sources: readonly LineageSource[];
+}
+export declare function identity(vaultId: string, path: string): PageIdentity;
+export declare function contentHash(digest: string, bytes: number): ContentHash;
+/**
+ * Cut a quote to the byte budget ON A UTF-8 BOUNDARY, and hash the FULL text either way.
+ *
+ * ⚠⚠ THE HASH IS OVER THE WHOLE QUOTE EVEN WHEN THE TEXT IS CUT, and that is the entire value of
+ * the truncation design. D4's repairability claim is that a stale stamp can be REPAIRED rather than
+ * merely flagged — which needs an identity for the text that was actually cited. Hashing the stored
+ * prefix instead would make a truncated span unverifiable against the source it came from: the
+ * recorded hash would match nothing, and the record would look healthy while proving nothing.
+ *
+ * ⚠ THE CUT IS ON A CODEPOINT BOUNDARY, NOT A `slice(0, 1024)`. A byte cut through a multibyte
+ * sequence yields text that does not re-encode to the bytes it came from, which is precisely the
+ * identity-destroying move `span.ts` refuses on every other path. `Buffer.write` into a fixed
+ * buffer does this natively: it never writes a partial character.
+ */
+export declare function storeQuote(text: string): StoredQuote;
+/**
+ * ⚠ THE SINGLE HOME OF THE SCRIBE'S CONTENT DIGEST, AND IT IS EXPORTED FOR THAT REASON RATHER THAN
+ * BECAUSE THREE CALLERS WANTED A SHORTER LINE. `source.ts` hashes what it re-read to prove the
+ * source did not move under it, `stamp.ts` hashes the page it is about to create, and this module
+ * hashes the recorded text — and those three digests are COMPARED WITH EACH OTHER downstream. Three
+ * inlined spellings of one algorithm can disagree the moment any one of them is edited, and the
+ * failure would read as a source that changed rather than as a hash that drifted.
+ *
+ * ⚠ The fence's `hashInGrant` is NOT this and must not be folded in: it streams a file in windows
+ * because a source is routinely a whole transcript, while this takes bytes already in hand.
+ */
+export declare function hashText(bytes: Buffer): string;
+export declare function lineageSpan(span: ResolvedSpan): LineageSpan;
+/**
+ * ⚠ THE KEY ORDER HERE IS THE WIRE ORDER, because `JSON.stringify` emits own keys in insertion
+ * order and a ledger line is a text artifact people will diff. Nothing depends on it semantically —
+ * a consumer parses JSON — but a format whose byte layout drifts between versions makes every diff
+ * of the ledger unreadable for no gain.
+ */
+export declare function serialiseRecord(record: LineageRecord): Buffer;
+/**
+ * The count bounds, checked BEFORE anything is serialised or written.
+ *
+ * ⚠ SPANS ARE COUNTED ACROSS ALL SOURCES, not per source. A per-source cap of 256 with 64 sources
+ * admits 16,384 spans, which is the bound this is supposed to be — the whole reason the cap exists
+ * is the serialised size of one line, and size is a property of the line rather than of a source.
+ */
+export declare function checkCounts(sources: readonly LineageSource[]): ScribeRefusal | null;
+/**
+ * The same two bounds, over counts taken from the REQUEST rather than from resolved records.
+ *
+ * ⚠⚠ IT EXISTS SO A GUARANTEED REFUSAL CAN BE DECIDED BEFORE ANY SOURCE IS READ. Both caps are
+ * knowable from the request's own shape — 65 `derived_from` entries is over the cap whether or not
+ * a single one of those files exists — so checking them only after the source loop meant reading
+ * every source to reach a conclusion that never depended on them, and leaking each one's existence
+ * and timing on the way. `stamp.ts`'s step 3 carries the full argument.
+ *
+ * ⚠ ONE IMPLEMENTATION, TWO ENTRY POINTS. `checkCounts` now delegates here rather than repeating
+ * the comparisons, so the pre-check and the post-resolution check can never disagree about a bound
+ * or about the words a refusal uses.
+ */
+export declare function checkPagePath(pagePath: string): ScribeRefusal | null;
+export declare function checkRequestCounts(sources: number, spans: number): ScribeRefusal | null;
+/**
+ * The size bound, checked on the SERIALISED bytes.
+ *
+ * ⚠ NEVER SPLIT A LINE. B4's atomicity argument is about one `write` of one complete line; a line
+ * split across two writes is exactly the interleaving the argument rules out, arriving through the
+ * repair for the case it could not handle. So an over-size line REFUSES and nothing is appended.
+ */
+export declare function checkLineSize(line: Buffer): ScribeRefusal | null;

package/dist/lineage.js

@@ -0,0 +1,194 @@
+/**
+ * THE LINEAGE LINE — `wyrd.lineage/v1`. One JSON object per line, LF-terminated, append-only (D3).
+ *
+ * ⚠⚠ EVERY IDENTITY CARRIES AN EXPLICIT DISCRIMINANT AND ITS VAULT, and both halves are rulings
+ * rather than taste (2026-08-31 identity block).
+ *
+ *   · `kind` exists so no consumer ever type-sniffs a string. J35 shipped a POLYMORPHIC SCALAR —
+ *     one field holding a capture id normally and a path for rows that can never have one — and
+ *     the measured cost was that every consumer needed a sniff branch, with ~84 edges hanging on
+ *     one of them being written correctly. Our format is JSONL. A structured format has no reason
+ *     to make a reader guess. A page with no stable id is PERMANENTLY `kind: 'path'`; it is never
+ *     `id: null`, and never a value with an explanatory suffix.
+ *   · `vault_id` exists because `.wyrd/lineage.jsonl` scopes identity IMPLICITLY, and implicit
+ *     scoping survives only while the record stays home. Magi is mage-to-mage, so a record WILL
+ *     travel, and the moment it does a bare path is ambiguous across two granted vaults —
+ *     the same defect the ruling exists to prevent, one layer up. The identity block gave two
+ *     acceptable answers and named picking neither as the failure. This is the first: the identity
+ *     carries its vault explicitly.
+ *
+ * ⚠⚠ THE LIMITS BELOW ARE POLICY BOUNDS, NOT PROVEN ATOMICITY GUARANTEES. B4's argument is that a
+ * single `write` of a complete line under `O_APPEND` does not interleave for writes below a
+ * pipe/PIPE_BUF-class threshold. That threshold is a property of the platform and the filesystem,
+ * it is not 65,536 anywhere in particular, and nothing in this repo has measured it. What these
+ * numbers actually buy is that a line CANNOT grow without bound through a large quote or a long
+ * `derived_from` list — so the atomicity argument is being made about a bounded object rather than
+ * an unbounded one. Calling that a guarantee would be the "confident number with no regime" shape
+ * this lane keeps catching in its own work.
+ */
+import { createHash } from 'node:crypto';
+import { scribeRefuse } from './refusal.js';
+export const LINEAGE_SCHEMA = 'wyrd.lineage/v1';
+/** ≤ 1,024 UTF-8 bytes of quote text retained; the rest is dropped and `truncated` says so. */
+export const QUOTE_BYTE_BUDGET = 1_024;
+/** At most this many `derived_from` entries per line. */
+export const MAX_SOURCES = 64;
+/** At most this many spans per line, summed across all sources. */
+export const MAX_SPANS = 256;
+/** The serialised line INCLUDING its terminating LF. */
+export const MAX_LINE_BYTES = 65_536;
+/**
+ * At most this many UTF-8 bytes in the page path, as the ledger spells it.
+ *
+ * ⚠⚠ IT EXISTS BECAUSE THE PAGE PATH WAS THE ONLY VARIABLE-WIDTH FIELD IN A BOUNDED LINE WITH NO
+ * BOUND OF ITS OWN. Quotes have `QUOTE_BYTE_BUDGET`, sources have `MAX_SOURCES`, spans have
+ * `MAX_SPANS`, the digest is fixed at 64 hex characters and the byte count is bounded by
+ * `Number.MAX_SAFE_INTEGER` — so every other contributor to `MAX_LINE_BYTES` could be reasoned
+ * about in advance, and one could not. A single 60,000-byte path was enough to consume the whole
+ * budget and starve fields the caller had every right to expect would fit.
+ *
+ * ⚠ 4,096 IS THE FENCE'S `MAX_GRANT_LENGTH`, DELIBERATELY. That constant bounds the grant ROOT and
+ * says nothing about the grant-RELATIVE path — measured 2026-09-03, an in-grant path was created
+ * at 16,407 characters with no refusal — so this is not a restatement of an existing guarantee.
+ * Reusing the number keeps one order of magnitude in the reader's head rather than two, and 4,096
+ * bytes of path is far past any real vault while leaving 61,440 bytes for everything else.
+ *
+ * ⚠ WHAT THIS DOES NOT CLOSE. The bound is checked against the path the CALLER asked for, and the
+ * ledger records the path the filesystem RESOLVED to; an in-grant junction can lengthen it after
+ * the page is created. `stamp.ts` step 9 remains the last line of defence for that case and now
+ * reports it honestly. Closing it properly needs a pre-write canonical path from the fence, which
+ * is a change to the Fence's public API and remains outside this module's contract.
+ */
+export const MAX_PAGE_PATH_BYTES = 4_096;
+export function identity(vaultId, path) {
+    return Object.freeze({ kind: 'path', vault_id: vaultId, path });
+}
+export function contentHash(digest, bytes) {
+    return Object.freeze({ algorithm: 'sha256', digest, bytes });
+}
+/**
+ * Cut a quote to the byte budget ON A UTF-8 BOUNDARY, and hash the FULL text either way.
+ *
+ * ⚠⚠ THE HASH IS OVER THE WHOLE QUOTE EVEN WHEN THE TEXT IS CUT, and that is the entire value of
+ * the truncation design. D4's repairability claim is that a stale stamp can be REPAIRED rather than
+ * merely flagged — which needs an identity for the text that was actually cited. Hashing the stored
+ * prefix instead would make a truncated span unverifiable against the source it came from: the
+ * recorded hash would match nothing, and the record would look healthy while proving nothing.
+ *
+ * ⚠ THE CUT IS ON A CODEPOINT BOUNDARY, NOT A `slice(0, 1024)`. A byte cut through a multibyte
+ * sequence yields text that does not re-encode to the bytes it came from, which is precisely the
+ * identity-destroying move `span.ts` refuses on every other path. `Buffer.write` into a fixed
+ * buffer does this natively: it never writes a partial character.
+ */
+export function storeQuote(text) {
+    const full = Buffer.from(text, 'utf8');
+    const sha256 = hashText(full);
+    if (full.length <= QUOTE_BYTE_BUDGET) {
+        return Object.freeze({
+            text,
+            original_utf8_bytes: full.length,
+            stored_utf8_bytes: full.length,
+            sha256,
+            truncated: false
+        });
+    }
+    // ⚠ `Buffer.write` STOPS AT THE LAST WHOLE CHARACTER THAT FITS, so `written` is a
+    // codepoint-aligned length by construction. Doing the arithmetic by hand here would be a second
+    // implementation of the boundary rule the fence already has one of.
+    const held = Buffer.allocUnsafe(QUOTE_BYTE_BUDGET);
+    const written = held.write(text, 0, QUOTE_BYTE_BUDGET, 'utf8');
+    const stored = held.subarray(0, written);
+    return Object.freeze({
+        text: stored.toString('utf8'),
+        original_utf8_bytes: full.length,
+        stored_utf8_bytes: written,
+        sha256,
+        truncated: true
+    });
+}
+/**
+ * ⚠ THE SINGLE HOME OF THE SCRIBE'S CONTENT DIGEST, AND IT IS EXPORTED FOR THAT REASON RATHER THAN
+ * BECAUSE THREE CALLERS WANTED A SHORTER LINE. `source.ts` hashes what it re-read to prove the
+ * source did not move under it, `stamp.ts` hashes the page it is about to create, and this module
+ * hashes the recorded text — and those three digests are COMPARED WITH EACH OTHER downstream. Three
+ * inlined spellings of one algorithm can disagree the moment any one of them is edited, and the
+ * failure would read as a source that changed rather than as a hash that drifted.
+ *
+ * ⚠ The fence's `hashInGrant` is NOT this and must not be folded in: it streams a file in windows
+ * because a source is routinely a whole transcript, while this takes bytes already in hand.
+ */
+export function hashText(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+export function lineageSpan(span) {
+    return Object.freeze({
+        offset: span.offset,
+        length: span.length,
+        quote: storeQuote(span.quote)
+    });
+}
+/**
+ * ⚠ THE KEY ORDER HERE IS THE WIRE ORDER, because `JSON.stringify` emits own keys in insertion
+ * order and a ledger line is a text artifact people will diff. Nothing depends on it semantically —
+ * a consumer parses JSON — but a format whose byte layout drifts between versions makes every diff
+ * of the ledger unreadable for no gain.
+ */
+export function serialiseRecord(record) {
+    return Buffer.from(`${JSON.stringify(record)}\n`, 'utf8');
+}
+/**
+ * The count bounds, checked BEFORE anything is serialised or written.
+ *
+ * ⚠ SPANS ARE COUNTED ACROSS ALL SOURCES, not per source. A per-source cap of 256 with 64 sources
+ * admits 16,384 spans, which is the bound this is supposed to be — the whole reason the cap exists
+ * is the serialised size of one line, and size is a property of the line rather than of a source.
+ */
+export function checkCounts(sources) {
+    let spans = 0;
+    for (const source of sources)
+        spans += source.spans.length;
+    return checkRequestCounts(sources.length, spans);
+}
+/**
+ * The same two bounds, over counts taken from the REQUEST rather than from resolved records.
+ *
+ * ⚠⚠ IT EXISTS SO A GUARANTEED REFUSAL CAN BE DECIDED BEFORE ANY SOURCE IS READ. Both caps are
+ * knowable from the request's own shape — 65 `derived_from` entries is over the cap whether or not
+ * a single one of those files exists — so checking them only after the source loop meant reading
+ * every source to reach a conclusion that never depended on them, and leaking each one's existence
+ * and timing on the way. `stamp.ts`'s step 3 carries the full argument.
+ *
+ * ⚠ ONE IMPLEMENTATION, TWO ENTRY POINTS. `checkCounts` now delegates here rather than repeating
+ * the comparisons, so the pre-check and the post-resolution check can never disagree about a bound
+ * or about the words a refusal uses.
+ */
+export function checkPagePath(pagePath) {
+    const bytes = Buffer.byteLength(pagePath, 'utf8');
+    if (bytes > MAX_PAGE_PATH_BYTES) {
+        return scribeRefuse('LINEAGE_LINE_TOO_LARGE', `the page path is ${bytes} bytes; the ceiling is ${MAX_PAGE_PATH_BYTES}`);
+    }
+    return null;
+}
+export function checkRequestCounts(sources, spans) {
+    if (sources > MAX_SOURCES) {
+        return scribeRefuse('LINEAGE_LINE_TOO_LARGE', `a lineage line carries at most ${MAX_SOURCES} sources`);
+    }
+    if (spans > MAX_SPANS) {
+        return scribeRefuse('LINEAGE_LINE_TOO_LARGE', `a lineage line carries at most ${MAX_SPANS} spans`);
+    }
+    return null;
+}
+/**
+ * The size bound, checked on the SERIALISED bytes.
+ *
+ * ⚠ NEVER SPLIT A LINE. B4's atomicity argument is about one `write` of one complete line; a line
+ * split across two writes is exactly the interleaving the argument rules out, arriving through the
+ * repair for the case it could not handle. So an over-size line REFUSES and nothing is appended.
+ */
+export function checkLineSize(line) {
+    if (line.length > MAX_LINE_BYTES) {
+        return scribeRefuse('LINEAGE_LINE_TOO_LARGE', `the serialised lineage line is ${line.length} bytes; the ceiling is ${MAX_LINE_BYTES}`);
+    }
+    return null;
+}
+//# sourceMappingURL=lineage.js.map

package/dist/lineage.js.map

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

package/dist/main.d.ts

@@ -0,0 +1,27 @@
+import type { Transport } from '@modelcontextprotocol/server';
+import type { FenceRefusal, FsGate } from 'wyrd-fence';
+import type { WritePageRequest, WritePageResult } from './stamp.js';
+interface Scribe {
+    writePage(request: WritePageRequest): Promise<WritePageResult>;
+}
+export interface MainDeps {
+    readonly argv: readonly string[];
+    readonly env: Record<string, string | undefined>;
+    readonly makeFsGate: (options: {
+        rawGrant: string;
+    }) => FsGate | FenceRefusal;
+    readonly makeScribe?: (options: {
+        readonly gate: FsGate;
+        readonly version: string;
+    }) => Scribe;
+    readonly makeTransport?: () => Transport;
+    readonly stderr: (line: string) => void;
+    readonly setExitCode: (code: number) => void;
+}
+export interface MainResult {
+    readonly started: boolean;
+    readonly reason: string | null;
+}
+/** Plan the tier first; only a successful plan may reach the grant or transport factories. */
+export declare function main(deps: MainDeps): Promise<MainResult>;
+export {};

package/dist/main.js

@@ -0,0 +1,169 @@
+import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
+import { isRefusal } from 'wyrd-fence';
+import { gateAppender } from './ledger.js';
+import { createServer, FENCE_DISCLOSURE, planTier, productionInstructions, SERVER_VERSION } from './server.js';
+import { SourceCache } from './source.js';
+import { writePage } from './stamp.js';
+function createScribe(options) {
+    const cache = new SourceCache();
+    const appender = options.appender ?? gateAppender(options.gate);
+    return Object.freeze({
+        writePage: (request) => writePage(request, {
+            gate: options.gate,
+            appender,
+            version: options.version,
+            cache
+        })
+    });
+}
+function writePageRegistration(context, activeTier) {
+    const description = [
+        `Tier ${activeTier}: attempt to create a page outside Arc/; target and sources use the grant fence.`,
+        '',
+        'The target is created exclusively. An occupied leaf refuses EXISTS; this tool does not',
+        'overwrite, delete or rename. The target and every derived_from.source are grant-relative',
+        'and go through the imported wyrd-fence implementation.',
+        '',
+        FENCE_DISCLOSURE,
+        '',
+        'Success creates the page and appends one lineage line. The vault configuration may also',
+        'project lineage into frontmatter. If the ledger fails after creation, the page stays in',
+        'place and the refusal includes both the created page and the underlying cause.'
+    ].join('\n');
+    const span = {
+        oneOf: [
+            {
+                type: 'object',
+                properties: {
+                    offset: { type: 'integer', minimum: 0 },
+                    length: { type: 'integer', minimum: 1 }
+                },
+                required: ['offset', 'length'],
+                additionalProperties: false
+            },
+            {
+                type: 'object',
+                properties: { quote: { type: 'string', minLength: 1 } },
+                required: ['quote'],
+                additionalProperties: false
+            },
+            {
+                type: 'object',
+                properties: {
+                    offset: { type: 'integer', minimum: 0 },
+                    length: { type: 'integer', minimum: 1 },
+                    quote: { type: 'string', minLength: 1 }
+                },
+                required: ['offset', 'length', 'quote'],
+                additionalProperties: false
+            }
+        ]
+    };
+    const registration = {
+        declaration: {
+            name: 'write_page',
+            title: 'Create a page with lineage',
+            description,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', minLength: 1 },
+                    content: { type: 'string' },
+                    derived_from: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                source: { type: 'string', minLength: 1 },
+                                spans: { type: 'array', minItems: 1, items: span }
+                            },
+                            required: ['source', 'spans'],
+                            additionalProperties: false
+                        }
+                    }
+                },
+                required: ['path', 'content', 'derived_from'],
+                additionalProperties: false
+                /*
+                 * ⚠ `span` above is `as const`, so its arrays are `readonly`, and v2's schema type
+                 * wants mutable ones. Same cause as the Reader's `READ_INPUT_SCHEMA_FOR_TOOL`
+                 * (`wyrd/src/server.ts`), and found the same way: by BUILDING against v2, which no
+                 * read-only review lane could do — three lanes read this plan and approved it.
+                 *
+                 * Widened at the boundary rather than by dropping `as const`. The literal types
+                 * document the three legal span shapes (offset+length, quote, or all three), and
+                 * that precision is enforced at runtime by the Scribe's own AJV validation, which
+                 * is the check that actually protects the vault. Structurally identical; only
+                 * readonly modifiers differ.
+                 */
+            }
+        },
+        call: async (args) => {
+            const { derived_from, ...rest } = args;
+            const result = await context.scribe.writePage({
+                ...rest,
+                derivedFrom: derived_from
+            });
+            const prefix = result.ok
+                ? 'wyrd-scribe completed write_page.'
+                : result.reason === 'PAGE_WRITTEN_LEDGER_FAILED'
+                    ? 'wyrd-scribe created the page, but no lineage append was confirmed; inspect `cause` and, when present, `cause.retained`, because the ledger may contain no new line, a fragment, or the complete line.'
+                    : 'wyrd-scribe refused write_page.';
+            const serialised = JSON.stringify(result);
+            return {
+                ...(result.ok ? {} : { isError: true }),
+                content: [{ type: 'text', text: `${prefix}\n${serialised}` }]
+            };
+        }
+    };
+    return Object.freeze(registration);
+}
+const PRODUCTION_LAYERS = Object.freeze({
+    A: (context, activeTier) => Object.freeze([
+        writePageRegistration(context, activeTier)
+    ]),
+    B: null,
+    C: null
+});
+function readGrantArg(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === '--grant')
+            return argv[index + 1] ?? '';
+        if (argument.startsWith('--grant='))
+            return argument.slice('--grant='.length);
+    }
+    return null;
+}
+/** Plan the tier first; only a successful plan may reach the grant or transport factories. */
+export async function main(deps) {
+    const planned = planTier(deps.env['WYRD_SCRIBE_TIER'], PRODUCTION_LAYERS);
+    if (!planned.ok) {
+        deps.stderr(planned.message);
+        deps.setExitCode(2);
+        return { started: false, reason: planned.reason };
+    }
+    const fromArgv = readGrantArg(deps.argv);
+    const rawGrant = fromArgv !== null ? fromArgv : (deps.env['WYRD_GRANT'] ?? null);
+    if (rawGrant === null || rawGrant === '') {
+        deps.stderr('wyrd-scribe: refusing to start — no folder has been granted; use --grant or WYRD_GRANT.');
+        deps.setExitCode(2);
+        return { started: false, reason: 'NO_GRANT' };
+    }
+    const gate = deps.makeFsGate({ rawGrant });
+    if (isRefusal(gate)) {
+        deps.stderr(`wyrd-scribe: refusing to start — ${gate.detail}`);
+        deps.setExitCode(2);
+        return { started: false, reason: gate.reason };
+    }
+    const context = Object.freeze({
+        instructions: (tier, names) => productionInstructions(gate.disclosedRoot(), tier, names),
+        scribe: deps.makeScribe?.({ gate, version: SERVER_VERSION })
+            ?? createScribe({ gate, version: SERVER_VERSION })
+    });
+    const server = createServer(planned, context);
+    const transport = deps.makeTransport?.() ?? new StdioServerTransport();
+    await server.connect(transport);
+    return { started: true, reason: null };
+}
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAG1E,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACH,YAAY,EACZ,gBAAgB,EAChB,QAAQ,EACR,sBAAsB,EACtB,cAAc,EACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAgCvC,SAAS,YAAY,CAAC,OAAsB;IACxC,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC;IAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,OAAO,MAAM,CAAC,MAAM,CAAC;QACjB,SAAS,EAAE,CAAC,OAAyB,EAAE,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE;YACzD,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,QAAQ;YACR,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,KAAK;SACR,CAAC;KACL,CAAC,CAAC;AACP,CAAC;AAED,SAAS,qBAAqB,CAAC,OAA0B,EAAE,UAAgB;IACvE,MAAM,WAAW,GAAG;QAChB,QAAQ,UAAU,kFAAkF;QACpG,EAAE;QACF,wFAAwF;QACxF,0FAA0F;QAC1F,wDAAwD;QACxD,EAAE;QACF,gBAAgB;QAChB,EAAE;QACF,yFAAyF;QACzF,yFAAyF;QACzF,gFAAgF;KACnF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,MAAM,IAAI,GAAG;QACT,KAAK,EAAE;YACH;gBACI,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACR,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;oBACvC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;iBAC1C;gBACD,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;gBAC9B,oBAAoB,EAAE,KAAK;aAC9B;YACD;gBACI,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE;gBACvD,QAAQ,EAAE,CAAC,OAAO,CAAC;gBACnB,oBAAoB,EAAE,KAAK;aAC9B;YACD;gBACI,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACR,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;oBACvC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;oBACvC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;iBAC1C;gBACD,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC;gBACvC,oBAAoB,EAAE,KAAK;aAC9B;SACJ;KACK,CAAC;IAEX,MAAM,YAAY,GAAqB;QACnC,WAAW,EAAE;YACT,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,4BAA4B;YACnC,WAAW;YACX,WAAW,EAAE;gBACT,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACR,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;oBACtC,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC3B,YAAY,EAAE;wBACV,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE;4BACH,IAAI,EAAE,QAAQ;4BACd,UAAU,EAAE;gCACR,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;gCACxC,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE;6BACrD;4BACD,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;4BAC7B,oBAAoB,EAAE,KAAK;yBAC9B;qBACJ;iBACJ;gBACD,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,cAAc,CAAC;gBAC7C,oBAAoB,EAAE,KAAK;gBAC3B;;;;;;;;;;;mBAWG;aAC4B;SACtC;QACD,IAAI,EAAE,KAAK,EAAC,IAAI,EAAC,EAAE;YACf,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;YACvC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC;gBAC1C,GAAG,IAAI;gBACP,WAAW,EAAE,YAAY;aACG,CAAC,CAAC;YAClC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE;gBACpB,CAAC,CAAC,mCAAmC;gBACrC,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,4BAA4B;oBAC5C,CAAC,CAAC,uMAAuM;oBACzM,CAAC,CAAC,iCAAiC,CAAC;YAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAC1C,OAAO;gBACH,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;gBACvC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,GAAG,MAAM,KAAK,UAAU,EAAE,EAAE,CAAC;aACzE,CAAC;QACN,CAAC;KACJ,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,iBAAiB,GAAkC,MAAM,CAAC,MAAM,CAAC;IACnE,CAAC,EAAE,CAAC,OAA0B,EAAE,UAAgB,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;QAC/D,qBAAqB,CAAC,OAAO,EAAE,UAAU,CAAC;KAC7C,CAAC;IACF,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;CACV,CAAC,CAAC;AAEH,SAAS,YAAY,CAAC,IAAuB;IACzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAW,CAAC;QACvC,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QACzD,IAAI,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC;YAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,8FAA8F;AAC9F,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,IAAc;IACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE,iBAAiB,CAAC,CAAC;IAC1E,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QACd,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;IACtD,CAAC;IAED,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,MAAM,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,CAAC;IACjF,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACvC,IAAI,CAAC,MAAM,CAAC,yFAAyF,CAAC,CAAC;QACvG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAClD,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3C,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,CAAC,oCAAoC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IACnD,CAAC;IAED,MAAM,OAAO,GAAsB,MAAM,CAAC,MAAM,CAAC;QAC7C,YAAY,EAAE,CAAC,IAAU,EAAE,KAAwB,EAAE,EAAE,CACnD,sBAAsB,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC;QAC7D,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;eACrD,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;KACzD,CAAC,CAAC;IACH,MAAM,MAAM,GAAW,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACtD,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,IAAI,oBAAoB,EAAE,CAAC;IACvE,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAC3C,CAAC"}

package/dist/refusal.d.ts

@@ -0,0 +1,36 @@
+/**
+ * THE SCRIBE'S OWN REFUSAL SHAPE, and the one rule that binds every field in it.
+ *
+ * ⚠⚠ NEVER A RESOLVED ABSOLUTE PATH IN A `detail`. This is the fence's `META-no-outside-names`
+ * property carried across the package boundary — the fence returns `rel` and never `actual`
+ * precisely so a refusal cannot become a filesystem oracle, and a Scribe refusal that echoed a
+ * caller-supplied path would hand that oracle back one layer up. So a Scribe `detail` names a
+ * CONSTANT (`.wyrd/scribe.json`) or a BOUND (`65536 bytes`), never a request string.
+ *
+ * ⚠ THE CALLER'S OWN REQUEST STRING IS NOT SAFE TO ECHO EITHER, and that is the non-obvious half.
+ * It looks harmless — the caller already knows what it sent — but the refusal travels to a MODEL
+ * driving the server over stdio, and echoing `C:\Users\...\secrets\x.md` back into a transcript
+ * puts an outside name in the one place the fence spent seven rounds keeping it out of. A refusal
+ * says which RULE fired; it does not repeat the request.
+ *
+ * ⚠ FENCE REFUSALS PASS THROUGH UNCHANGED and are NOT re-wrapped in this shape. A parallel
+ * vocabulary for `ESCAPES`/`MISSING`/`EXISTS` would be a second thing to get wrong, and D8's whole
+ * argument is that there is one containment implementation and one set of words for its outcomes.
+ * `SOURCE_MISSING` in the spec's prose IS the fence's `MISSING`; it is not a distinct reason.
+ */
+/**
+ * The reasons the Scribe itself originates. `ARC_IMMUTABLE` is doctrine (D7) rather than a fence
+ * outcome, so it lives here with the rest.
+ */
+export type ScribeReason = 'BAD_INPUT' | 'DERIVED_FROM_INVALID' | 'ARC_IMMUTABLE' | 'SCRIBE_NOT_INITIALISED' | 'SCRIBE_CONFIG_INVALID' | 'SCRIBE_CONFIG_TOO_LARGE' | 'SOURCE_CHANGED_DURING_READ' | 'FRONTMATTER_INVALID' | 'FRONTMATTER_CONFLICT' | 'LINEAGE_LINE_TOO_LARGE' | 'PAGE_WRITTEN_LEDGER_FAILED';
+/**
+ * ⚠ NO `resolvedPath`, DELIBERATELY. The fence carries that field because a CONFIG refusal names
+ * the grant the user themselves configured; a Scribe refusal has no such field to fill honestly,
+ * and an empty-string placeholder would be a slot a later session fills with the wrong thing.
+ */
+export interface ScribeRefusal {
+    readonly ok: false;
+    readonly reason: ScribeReason;
+    readonly detail: string;
+}
+export declare function scribeRefuse(reason: ScribeReason, detail: string): ScribeRefusal;