framein 0.0.4 → 0.0.5

package/dist/mcpServer.js

@@ -1,138 +1,138 @@
-// Thin framein MCP surface (F-OWN-1): the minimum tools agents need to share the store.
-// `handleTool` maps a tool call to a store op (unit-tested); `dispatch` handles one JSON-RPC
-// message; `serve` is the stdio loop. The wire format is newline-delimited JSON (NDJSON) —
-// that IS the MCP stdio transport (ADR-0007). MCP stdio is NOT Content-Length framed (that's
-// LSP); headers only appear in MCP's separate Streamable HTTP transport. Live MCP-CLIENT
-// wiring (each CLI launching its own `frame mcp serve`) is the orchestration layer (B).
-import { createInterface } from 'node:readline';
-const obj = (properties, required = []) => ({ type: 'object', properties, required });
-const str = { type: 'string' };
-export const TOOLS = [
-    { name: 'append_adr', description: 'record an ADR', inputSchema: obj({ title: str, decision: str, context: str, consequences: str }, ['title']) },
-    { name: 'list_adr', description: 'list all ADRs', inputSchema: obj({}) },
-    { name: 'get_adr', description: 'get one ADR', inputSchema: obj({ id: { type: 'number' } }, ['id']) },
-    { name: 'read_memory', description: 'read scoped memory', inputSchema: obj({ scope: str, key: str }, ['scope', 'key']) },
-    { name: 'write_memory', description: 'write scoped memory', inputSchema: obj({ scope: str, key: str, value: {} }, ['scope', 'key', 'value']) },
-    { name: 'list_memory', description: 'list a memory scope', inputSchema: obj({ scope: str }, ['scope']) },
-    { name: 'get_role', description: 'agent assigned to a role', inputSchema: obj({ role: str }, ['role']) },
-    { name: 'get_roles', description: 'all role assignments', inputSchema: obj({}) },
-    { name: 'acquire_lock', description: 'acquire the write lock', inputSchema: obj({ holder: str, scope: str }, ['holder']) },
-    { name: 'release_lock', description: 'release the write lock', inputSchema: obj({ holder: str, scope: str }, ['holder']) },
-];
-const TOOL_NAMES = new Set(TOOLS.map((t) => t.name));
-/** Protocol versions we accept, newest first. Negotiation echoes the client's if supported. */
-export const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
-// Advertised to clients; keep loosely in sync with package.json (a string is required by spec).
-const SERVER_INFO = { name: 'framein', version: '0.0.1' };
-export function handleTool(store, name, args = {}) {
-    switch (name) {
-        case 'append_adr': {
-            const title = String(args.title ?? '');
-            if (!title)
-                throw new Error('append_adr requires a title');
-            const a = store.appendAdr({
-                title,
-                decision: String(args.decision ?? title),
-                context: args.context,
-                consequences: args.consequences,
-            });
-            return { id: a.id };
-        }
-        case 'list_adr': return store.listAdrs();
-        case 'get_adr': return store.getAdr(Number(args.id)) ?? null;
-        case 'read_memory': return store.getMemory(String(args.scope), String(args.key)) ?? null;
-        case 'write_memory':
-            store.setMemory(String(args.scope), String(args.key), args.value);
-            return { ok: true };
-        case 'list_memory': return store.listMemory(String(args.scope));
-        case 'get_role': return store.getRole(args.role) ?? null;
-        case 'get_roles': return store.getRoles();
-        case 'acquire_lock': return { acquired: store.acquireLock(String(args.holder), { scope: args.scope }) };
-        case 'release_lock': return { released: store.releaseLock(String(args.holder), { scope: args.scope }) };
-        default: throw new Error(`unknown tool: ${name}`);
-    }
-}
-/**
- * Dispatch one parsed JSON-RPC value. Never throws. Returns a reply object for requests, or
- * `null` for notifications and for anything we can't reply to (no id). When a `session` is
- * supplied, the initialize-first lifecycle is enforced (ADR-0007); without one, dispatch stays
- * lenient (used by unit tests). `initialize` and `ping` are always allowed pre-init.
- */
-export function dispatch(store, req, session) {
-    const isObj = typeof req === 'object' && req !== null && !Array.isArray(req);
-    const r = (isObj ? req : {});
-    const hasId = isObj && 'id' in r && r.id !== null && r.id !== undefined;
-    const id = hasId ? r.id : null;
-    const params = (typeof r.params === 'object' && r.params !== null ? r.params : {});
-    const reply = (result) => (hasId ? { jsonrpc: '2.0', id, result } : null);
-    const errReply = (code, message) => (hasId ? { jsonrpc: '2.0', id, error: { code, message } } : null);
-    if (typeof r.method !== 'string')
-        return errReply(-32600, 'invalid request');
-    const method = r.method;
-    // Lifecycle methods allowed before initialization completes.
-    if (method === 'notifications/initialized') {
-        if (session)
-            session.initialized = true;
-        return null;
-    }
-    if (method === 'initialize') {
-        if (session)
-            session.initialized = false; // re-init resets; the initialized notification re-arms it
-        const want = params.protocolVersion;
-        const protocolVersion = typeof want === 'string' && PROTOCOL_VERSIONS.includes(want) ? want : PROTOCOL_VERSIONS[0];
-        return reply({ protocolVersion, serverInfo: SERVER_INFO, capabilities: { tools: { listChanged: false } } });
-    }
-    if (method === 'ping')
-        return reply({});
-    if (session && !session.initialized)
-        return errReply(-32600, 'received request before initialization');
-    try {
-        switch (method) {
-            case 'tools/list': return reply({ tools: TOOLS });
-            case 'tools/call': {
-                const name = params.name;
-                if (typeof name !== 'string' || !TOOL_NAMES.has(name))
-                    return errReply(-32602, `unknown tool: ${String(name)}`);
-                const args = (typeof params.arguments === 'object' && params.arguments !== null ? params.arguments : {});
-                try {
-                    const out = handleTool(store, name, args);
-                    return reply({ content: [{ type: 'text', text: JSON.stringify(out) }], isError: false });
-                }
-                catch (e) {
-                    // Tool EXECUTION errors stay in-band (isError) so the model sees them and can recover.
-                    return reply({ content: [{ type: 'text', text: e.message }], isError: true });
-                }
-            }
-            default: return errReply(-32601, `unknown method: ${method}`);
-        }
-    }
-    catch (e) {
-        return errReply(-32603, e.message);
-    }
-}
-/**
- * MCP stdio loop: newline-delimited JSON-RPC over stdin/stdout (the MCP stdio transport — not
- * Content-Length framing, ADR-0007). A malformed line is answered with a JSON-RPC parse error
- * (-32700), not silently dropped. Only valid MCP messages are written to `output` (stdout
- * hygiene); diagnostics belong on stderr. Consumes input until EOF.
- */
-export async function serve(store, input = process.stdin, output = process.stdout) {
-    const rl = createInterface({ input, crlfDelay: Infinity });
-    const session = { initialized: false };
-    for await (const line of rl) {
-        const t = line.trim();
-        if (!t)
-            continue;
-        let req;
-        try {
-            req = JSON.parse(t);
-        }
-        catch {
-            output.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } }) + '\n');
-            continue;
-        }
-        const res = dispatch(store, req, session);
-        if (res)
-            output.write(JSON.stringify(res) + '\n');
-    }
-}
+// Thin framein MCP surface (F-OWN-1): the minimum tools agents need to share the store.
+// `handleTool` maps a tool call to a store op (unit-tested); `dispatch` handles one JSON-RPC
+// message; `serve` is the stdio loop. The wire format is newline-delimited JSON (NDJSON) —
+// that IS the MCP stdio transport (ADR-0007). MCP stdio is NOT Content-Length framed (that's
+// LSP); headers only appear in MCP's separate Streamable HTTP transport. Live MCP-CLIENT
+// wiring (each CLI launching its own `frame mcp serve`) is the orchestration layer (B).
+import { createInterface } from 'node:readline';
+const obj = (properties, required = []) => ({ type: 'object', properties, required });
+const str = { type: 'string' };
+export const TOOLS = [
+    { name: 'append_adr', description: 'record an ADR', inputSchema: obj({ title: str, decision: str, context: str, consequences: str }, ['title']) },
+    { name: 'list_adr', description: 'list all ADRs', inputSchema: obj({}) },
+    { name: 'get_adr', description: 'get one ADR', inputSchema: obj({ id: { type: 'number' } }, ['id']) },
+    { name: 'read_memory', description: 'read scoped memory', inputSchema: obj({ scope: str, key: str }, ['scope', 'key']) },
+    { name: 'write_memory', description: 'write scoped memory', inputSchema: obj({ scope: str, key: str, value: {} }, ['scope', 'key', 'value']) },
+    { name: 'list_memory', description: 'list a memory scope', inputSchema: obj({ scope: str }, ['scope']) },
+    { name: 'get_role', description: 'agent assigned to a role', inputSchema: obj({ role: str }, ['role']) },
+    { name: 'get_roles', description: 'all role assignments', inputSchema: obj({}) },
+    { name: 'acquire_lock', description: 'acquire the write lock', inputSchema: obj({ holder: str, scope: str }, ['holder']) },
+    { name: 'release_lock', description: 'release the write lock', inputSchema: obj({ holder: str, scope: str }, ['holder']) },
+];
+const TOOL_NAMES = new Set(TOOLS.map((t) => t.name));
+/** Protocol versions we accept, newest first. Negotiation echoes the client's if supported. */
+export const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+// Advertised to clients; keep loosely in sync with package.json (a string is required by spec).
+const SERVER_INFO = { name: 'framein', version: '0.0.1' };
+export function handleTool(store, name, args = {}) {
+    switch (name) {
+        case 'append_adr': {
+            const title = String(args.title ?? '');
+            if (!title)
+                throw new Error('append_adr requires a title');
+            const a = store.appendAdr({
+                title,
+                decision: String(args.decision ?? title),
+                context: args.context,
+                consequences: args.consequences,
+            });
+            return { id: a.id };
+        }
+        case 'list_adr': return store.listAdrs();
+        case 'get_adr': return store.getAdr(Number(args.id)) ?? null;
+        case 'read_memory': return store.getMemory(String(args.scope), String(args.key)) ?? null;
+        case 'write_memory':
+            store.setMemory(String(args.scope), String(args.key), args.value);
+            return { ok: true };
+        case 'list_memory': return store.listMemory(String(args.scope));
+        case 'get_role': return store.getRole(args.role) ?? null;
+        case 'get_roles': return store.getRoles();
+        case 'acquire_lock': return { acquired: store.acquireLock(String(args.holder), { scope: args.scope }) };
+        case 'release_lock': return { released: store.releaseLock(String(args.holder), { scope: args.scope }) };
+        default: throw new Error(`unknown tool: ${name}`);
+    }
+}
+/**
+ * Dispatch one parsed JSON-RPC value. Never throws. Returns a reply object for requests, or
+ * `null` for notifications and for anything we can't reply to (no id). When a `session` is
+ * supplied, the initialize-first lifecycle is enforced (ADR-0007); without one, dispatch stays
+ * lenient (used by unit tests). `initialize` and `ping` are always allowed pre-init.
+ */
+export function dispatch(store, req, session) {
+    const isObj = typeof req === 'object' && req !== null && !Array.isArray(req);
+    const r = (isObj ? req : {});
+    const hasId = isObj && 'id' in r && r.id !== null && r.id !== undefined;
+    const id = hasId ? r.id : null;
+    const params = (typeof r.params === 'object' && r.params !== null ? r.params : {});
+    const reply = (result) => (hasId ? { jsonrpc: '2.0', id, result } : null);
+    const errReply = (code, message) => (hasId ? { jsonrpc: '2.0', id, error: { code, message } } : null);
+    if (typeof r.method !== 'string')
+        return errReply(-32600, 'invalid request');
+    const method = r.method;
+    // Lifecycle methods allowed before initialization completes.
+    if (method === 'notifications/initialized') {
+        if (session)
+            session.initialized = true;
+        return null;
+    }
+    if (method === 'initialize') {
+        if (session)
+            session.initialized = false; // re-init resets; the initialized notification re-arms it
+        const want = params.protocolVersion;
+        const protocolVersion = typeof want === 'string' && PROTOCOL_VERSIONS.includes(want) ? want : PROTOCOL_VERSIONS[0];
+        return reply({ protocolVersion, serverInfo: SERVER_INFO, capabilities: { tools: { listChanged: false } } });
+    }
+    if (method === 'ping')
+        return reply({});
+    if (session && !session.initialized)
+        return errReply(-32600, 'received request before initialization');
+    try {
+        switch (method) {
+            case 'tools/list': return reply({ tools: TOOLS });
+            case 'tools/call': {
+                const name = params.name;
+                if (typeof name !== 'string' || !TOOL_NAMES.has(name))
+                    return errReply(-32602, `unknown tool: ${String(name)}`);
+                const args = (typeof params.arguments === 'object' && params.arguments !== null ? params.arguments : {});
+                try {
+                    const out = handleTool(store, name, args);
+                    return reply({ content: [{ type: 'text', text: JSON.stringify(out) }], isError: false });
+                }
+                catch (e) {
+                    // Tool EXECUTION errors stay in-band (isError) so the model sees them and can recover.
+                    return reply({ content: [{ type: 'text', text: e.message }], isError: true });
+                }
+            }
+            default: return errReply(-32601, `unknown method: ${method}`);
+        }
+    }
+    catch (e) {
+        return errReply(-32603, e.message);
+    }
+}
+/**
+ * MCP stdio loop: newline-delimited JSON-RPC over stdin/stdout (the MCP stdio transport — not
+ * Content-Length framing, ADR-0007). A malformed line is answered with a JSON-RPC parse error
+ * (-32700), not silently dropped. Only valid MCP messages are written to `output` (stdout
+ * hygiene); diagnostics belong on stderr. Consumes input until EOF.
+ */
+export async function serve(store, input = process.stdin, output = process.stdout) {
+    const rl = createInterface({ input, crlfDelay: Infinity });
+    const session = { initialized: false };
+    for await (const line of rl) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let req;
+        try {
+            req = JSON.parse(t);
+        }
+        catch {
+            output.write(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } }) + '\n');
+            continue;
+        }
+        const res = dispatch(store, req, session);
+        if (res)
+            output.write(JSON.stringify(res) + '\n');
+    }
+}

package/dist/palette.js

@@ -1,63 +1,63 @@
-// Pure core for the lobby's inline `/` command palette (Claude-style, non-modal). Unlike the modal
-// picker (select.ts), here the TYPED LINE is primary: a suggestion list appears *below* the line you're
-// editing as soon as it starts with `/`, filters as you type, and ⏎ runs exactly what you typed — it
-// never force-selects the top item. ↑/↓ opt into picking a suggestion; ⏎ then runs the highlighted one.
-// No npm deps, no I/O — the raw-mode stdin loop + ANSI redraw live in cli.ts (readLobbyLine).
-export function initPalette(buf = '') { return { buf, index: 0, navigated: false }; }
-/** Suggestions are shown ONLY while the buffer is a slash-command being typed (`/…`). Filtered by the
- *  text after the leading `/` (substring over cmd + desc). Empty when the line isn't a slash command —
- *  so bare verbs / agent names (`verify`, `codex fix bug`) type freely with no popup. */
-export function paletteSuggestions(buf, cmds) {
-    if (!buf.startsWith('/'))
-        return [];
-    const q = buf.slice(1).trim().toLowerCase();
-    if (!q)
-        return cmds;
-    return cmds.filter((c) => `${c.cmd} ${c.desc}`.toLowerCase().includes(q));
-}
-/** Pure reducer: (state, key) → next state OR a terminal step. Mirrors select.ts but the default ⏎
- *  action is "run what I typed", not "accept the highlighted item". */
-export function reducePaletteKey(state, key, cmds) {
-    const sugg = paletteSuggestions(state.buf, cmds);
-    const n = sugg.length;
-    const idx = n ? Math.min(state.index, n - 1) : 0;
-    if (key.ctrl && key.name === 'c')
-        return { kind: 'sigint' };
-    if (key.ctrl && key.name === 'd')
-        return state.buf ? { kind: 'edit', state } : { kind: 'exit' };
-    if (key.name === 'escape')
-        return { kind: 'edit', state: initPalette('') }; // close the palette / clear the line
-    if (key.name === 'return' || key.name === 'enter') {
-        if (n && state.navigated)
-            return { kind: 'submit', line: sugg[idx].cmd }; // user picked one → run it
-        const line = state.buf.trim();
-        if (line === '' || line === '/')
-            return { kind: 'edit', state }; // nothing meaningful typed → no-op
-        return { kind: 'submit', line };
-    }
-    if (key.name === 'up')
-        return { kind: 'edit', state: { ...state, index: n ? (idx - 1 + n) % n : 0, navigated: true } };
-    if (key.name === 'down')
-        return { kind: 'edit', state: { ...state, index: n ? (idx + 1) % n : 0, navigated: true } };
-    if (key.name === 'tab')
-        return n ? { kind: 'edit', state: { buf: `${sugg[idx].cmd} `, index: 0, navigated: false } } : { kind: 'edit', state };
-    if (key.name === 'backspace')
-        return { kind: 'edit', state: { ...state, buf: state.buf.slice(0, -1), index: 0, navigated: false } };
-    // A single printable character extends the line (control sequences ignored). Typing resets the
-    // highlight so ⏎ goes back to "run what I typed" until the user navigates again.
-    const ch = key.sequence;
-    if (ch && ch.length === 1 && ch >= ' ' && !key.ctrl) {
-        return { kind: 'edit', state: { ...state, buf: state.buf + ch, index: 0, navigated: false } };
-    }
-    return { kind: 'edit', state };
-}
-/** Pure renderer for the suggestion list drawn below the input line (no ANSI; the I/O layer colors the
- *  hints). Returns [] when no suggestions are visible. The input line itself is drawn by the caller. */
-export function renderPaletteSuggestions(state, cmds, marker = '>') {
-    const sugg = paletteSuggestions(state.buf, cmds);
-    if (!sugg.length)
-        return [];
-    const w = Math.max(...sugg.map((c) => c.cmd.length));
-    const idx = Math.min(state.index, sugg.length - 1);
-    return sugg.map((c, i) => `${i === idx ? `${marker} ` : '  '}${c.cmd.padEnd(w)}   ${c.desc}`);
-}
+// Pure core for the lobby's inline `/` command palette (Claude-style, non-modal). Unlike the modal
+// picker (select.ts), here the TYPED LINE is primary: a suggestion list appears *below* the line you're
+// editing as soon as it starts with `/`, filters as you type, and ⏎ runs exactly what you typed — it
+// never force-selects the top item. ↑/↓ opt into picking a suggestion; ⏎ then runs the highlighted one.
+// No npm deps, no I/O — the raw-mode stdin loop + ANSI redraw live in cli.ts (readLobbyLine).
+export function initPalette(buf = '') { return { buf, index: 0, navigated: false }; }
+/** Suggestions are shown ONLY while the buffer is a slash-command being typed (`/…`). Filtered by the
+ *  text after the leading `/` (substring over cmd + desc). Empty when the line isn't a slash command —
+ *  so bare verbs / agent names (`verify`, `codex fix bug`) type freely with no popup. */
+export function paletteSuggestions(buf, cmds) {
+    if (!buf.startsWith('/'))
+        return [];
+    const q = buf.slice(1).trim().toLowerCase();
+    if (!q)
+        return cmds;
+    return cmds.filter((c) => `${c.cmd} ${c.desc}`.toLowerCase().includes(q));
+}
+/** Pure reducer: (state, key) → next state OR a terminal step. Mirrors select.ts but the default ⏎
+ *  action is "run what I typed", not "accept the highlighted item". */
+export function reducePaletteKey(state, key, cmds) {
+    const sugg = paletteSuggestions(state.buf, cmds);
+    const n = sugg.length;
+    const idx = n ? Math.min(state.index, n - 1) : 0;
+    if (key.ctrl && key.name === 'c')
+        return { kind: 'sigint' };
+    if (key.ctrl && key.name === 'd')
+        return state.buf ? { kind: 'edit', state } : { kind: 'exit' };
+    if (key.name === 'escape')
+        return { kind: 'edit', state: initPalette('') }; // close the palette / clear the line
+    if (key.name === 'return' || key.name === 'enter') {
+        if (n && state.navigated)
+            return { kind: 'submit', line: sugg[idx].cmd }; // user picked one → run it
+        const line = state.buf.trim();
+        if (line === '' || line === '/')
+            return { kind: 'edit', state }; // nothing meaningful typed → no-op
+        return { kind: 'submit', line };
+    }
+    if (key.name === 'up')
+        return { kind: 'edit', state: { ...state, index: n ? (idx - 1 + n) % n : 0, navigated: true } };
+    if (key.name === 'down')
+        return { kind: 'edit', state: { ...state, index: n ? (idx + 1) % n : 0, navigated: true } };
+    if (key.name === 'tab')
+        return n ? { kind: 'edit', state: { buf: `${sugg[idx].cmd} `, index: 0, navigated: false } } : { kind: 'edit', state };
+    if (key.name === 'backspace')
+        return { kind: 'edit', state: { ...state, buf: state.buf.slice(0, -1), index: 0, navigated: false } };
+    // A single printable character extends the line (control sequences ignored). Typing resets the
+    // highlight so ⏎ goes back to "run what I typed" until the user navigates again.
+    const ch = key.sequence;
+    if (ch && ch.length === 1 && ch >= ' ' && !key.ctrl) {
+        return { kind: 'edit', state: { ...state, buf: state.buf + ch, index: 0, navigated: false } };
+    }
+    return { kind: 'edit', state };
+}
+/** Pure renderer for the suggestion list drawn below the input line (no ANSI; the I/O layer colors the
+ *  hints). Returns [] when no suggestions are visible. The input line itself is drawn by the caller. */
+export function renderPaletteSuggestions(state, cmds, marker = '>') {
+    const sugg = paletteSuggestions(state.buf, cmds);
+    if (!sugg.length)
+        return [];
+    const w = Math.max(...sugg.map((c) => c.cmd.length));
+    const idx = Math.min(state.index, sugg.length - 1);
+    return sugg.map((c, i) => `${i === idx ? `${marker} ` : '  '}${c.cmd.padEnd(w)}   ${c.desc}`);
+}

package/dist/projector.js

@@ -1,65 +1,65 @@
-// Projects the single source of truth into the three native context files.
-// The canonical CORE BLOCK is byte-identical across all three => guaranteed sync.
-import { buildAdrDigest } from './adr.js';
-import { renderContractDigest } from './task.js';
-import { wrapManaged, upsertManagedBlock } from './managedBlock.js';
-export function buildCoreBlock(state) {
-    const rulesVal = state.config['rules'];
-    const rules = typeof rulesVal === 'string' && rulesVal.trim() ? rulesVal.trim() : '_No project rules defined._';
-    const roleEntries = Object.entries(state.roles);
-    const roleLines = roleEntries.length === 0
-        ? '_No roles assigned._'
-        : roleEntries.map(([r, a]) => `- **${r}** → ${a}`).join('\n');
-    const contract = state.taskContract ? renderContractDigest(state.taskContract) : '_No active task contract._';
-    // Operating guide for the AGENT (ADR-0012): framein is driven from inside your normal flow, not by the
-    // human typing long commands. Run any verb with the shell (`framein <verb>`) or the host slash command.
-    const guide = [
-        'This project is kept aligned by **framein** (intent → validation → continuity). Drive it from your',
-        'normal flow — run a verb with the shell (`framein <verb>`) or the host command (`/fr:<verb>`, Codex',
-        '`$fr-<verb>`). Automation-facing verbs expose `--json`; use the generated wrapper syntax when available.',
-        'On Windows PowerShell, use `framein.cmd <verb>` if the npm `.ps1` shim is blocked; generated wrappers already do this.',
-        '',
-        '- **At session start (and after any model switch)** — run `framein capsule` first to load where the',
-        '  project left off (last-green commit, recent changes, open blocker, decisions). This is how context',
-        '  follows you across models — don\'t ask the user to re-explain.',
-        '- **Task start** — fix what "done" means before coding: `framein start "<goal>"`, then',
-        '  `framein task amend acceptance|nongoal|protected "<…>"`. Changes auto-apply and show up in `git diff` —',
-        '  keep them honest; the human reviews. Don\'t silently drift the contract.',
-        '- **Before you claim done** — run the Validation Gate: `framein verify`. Never report "done" without it.',
-        '- **Ship** — `framein ship` for commit/deploy readiness.',
-        '- **Risky change** (auth · payments · migrations · deploy · secrets) — `framein risk`, then satisfy the required gates.',
-        '- **Stuck in a repeat-fix loop** — `framein rescue` (it proposes options; it never auto-acts).',
-        '- **Want a second opinion** — `framein challenge "<proposal>" --run` gets an INDEPENDENT model\'s verdict',
-        '  (a *different* model reviews — don\'t write the critique yourself; you keep the lead and `decide`).',
-        '- **Hand work to another model** — `framein capsule <agent>`, then exit; framein switches to that model,',
-        '  which loads the capsule on arrival. The context follows the handoff automatically.',
-        '',
-        'The **Task Contract** below is the definition of done — honor it. The human stays the final gate.',
-    ].join('\n');
-    return [
-        '## Working with framein', guide, '',
-        '## Task Contract', contract, '',
-        '## Project Rules', rules, '',
-        '_Project defaults — change them with `framein rules set "<…>"` (edits typed directly here are overwritten on sync). They guide the agent; the Validation Gate is what\'s enforced._', '',
-        '## Agent Roles', roleLines, '',
-        '## Architecture Decisions (digest)', buildAdrDigest(state.adrs),
-    ].join('\n');
-}
-/** The managed block (markers + canonical core), byte-identical across all three files. */
-export function renderManagedBlock(state) {
-    return wrapManaged(buildCoreBlock(state));
-}
-/** A from-scratch native file (heading + managed block); used when no file exists yet. */
-function projectFresh(title, state) {
-    return upsertManagedBlock(null, title, renderManagedBlock(state));
-}
-export function projectClaudeMd(state) { return projectFresh('CLAUDE.md', state); }
-export function projectAgentsMd(state) { return projectFresh('AGENTS.md', state); }
-export function projectGeminiMd(state) { return projectFresh('GEMINI.md', state); }
-export function projectAll(state) {
-    return {
-        'CLAUDE.md': projectClaudeMd(state),
-        'AGENTS.md': projectAgentsMd(state),
-        'GEMINI.md': projectGeminiMd(state),
-    };
-}
+// Projects the single source of truth into the three native context files.
+// The canonical CORE BLOCK is byte-identical across all three => guaranteed sync.
+import { buildAdrDigest } from './adr.js';
+import { renderContractDigest } from './task.js';
+import { wrapManaged, upsertManagedBlock } from './managedBlock.js';
+export function buildCoreBlock(state) {
+    const rulesVal = state.config['rules'];
+    const rules = typeof rulesVal === 'string' && rulesVal.trim() ? rulesVal.trim() : '_No project rules defined._';
+    const roleEntries = Object.entries(state.roles);
+    const roleLines = roleEntries.length === 0
+        ? '_No roles assigned._'
+        : roleEntries.map(([r, a]) => `- **${r}** → ${a}`).join('\n');
+    const contract = state.taskContract ? renderContractDigest(state.taskContract) : '_No active task contract._';
+    // Operating guide for the AGENT (ADR-0012): framein is driven from inside your normal flow, not by the
+    // human typing long commands. Run any verb with the shell (`framein <verb>`) or the host slash command.
+    const guide = [
+        'This project is kept aligned by **framein** (intent → validation → continuity). Drive it from your',
+        'normal flow — run a verb with the shell (`framein <verb>`) or the host command (`/fr:<verb>`, Codex',
+        '`$fr-<verb>`). Automation-facing verbs expose `--json`; use the generated wrapper syntax when available.',
+        'On Windows PowerShell, use `framein.cmd <verb>` if the npm `.ps1` shim is blocked; generated wrappers already do this.',
+        '',
+        '- **At session start (and after any model switch)** — run `framein capsule` first to load where the',
+        '  project left off (last-green commit, recent changes, open blocker, decisions). This is how context',
+        '  follows you across models — don\'t ask the user to re-explain.',
+        '- **Task start** — fix what "done" means before coding: `framein start "<goal>"`, then',
+        '  `framein task amend acceptance|nongoal|protected "<…>"`. Changes auto-apply and show up in `git diff` —',
+        '  keep them honest; the human reviews. Don\'t silently drift the contract.',
+        '- **Before you claim done** — run the Validation Gate: `framein verify`. Never report "done" without it.',
+        '- **Ship** — `framein ship` for commit/deploy readiness.',
+        '- **Risky change** (auth · payments · migrations · deploy · secrets) — `framein risk`, then satisfy the required gates.',
+        '- **Stuck in a repeat-fix loop** — `framein rescue` (it proposes options; it never auto-acts).',
+        '- **Want a second opinion** — `framein challenge "<proposal>" --run` gets an INDEPENDENT model\'s verdict',
+        '  (a *different* model reviews — don\'t write the critique yourself; you keep the lead and `decide`).',
+        '- **Hand work to another model** — `framein capsule <agent>`, then exit; framein switches to that model,',
+        '  which loads the capsule on arrival. The context follows the handoff automatically.',
+        '',
+        'The **Task Contract** below is the definition of done — honor it. The human stays the final gate.',
+    ].join('\n');
+    return [
+        '## Working with framein', guide, '',
+        '## Task Contract', contract, '',
+        '## Project Rules', rules, '',
+        '_Project defaults — change them with `framein rules set "<…>"` (edits typed directly here are overwritten on sync). They guide the agent; the Validation Gate is what\'s enforced._', '',
+        '## Agent Roles', roleLines, '',
+        '## Architecture Decisions (digest)', buildAdrDigest(state.adrs),
+    ].join('\n');
+}
+/** The managed block (markers + canonical core), byte-identical across all three files. */
+export function renderManagedBlock(state) {
+    return wrapManaged(buildCoreBlock(state));
+}
+/** A from-scratch native file (heading + managed block); used when no file exists yet. */
+function projectFresh(title, state) {
+    return upsertManagedBlock(null, title, renderManagedBlock(state));
+}
+export function projectClaudeMd(state) { return projectFresh('CLAUDE.md', state); }
+export function projectAgentsMd(state) { return projectFresh('AGENTS.md', state); }
+export function projectGeminiMd(state) { return projectFresh('GEMINI.md', state); }
+export function projectAll(state) {
+    return {
+        'CLAUDE.md': projectClaudeMd(state),
+        'AGENTS.md': projectAgentsMd(state),
+        'GEMINI.md': projectGeminiMd(state),
+    };
+}

package/dist/quota.js

@@ -1,30 +1,30 @@
-// Reactive quota detection (F-ROLE-3). Parse a CLI's stderr/output for rate-limit / quota /
-// overload signals so the orchestrator can fail over to another agent. This is NOT "bypassing
-// limits" — it routes work within each subscription's normal use. Pure + fixture-tested; the
-// live capture of `output` (a real CLI run) is the B-layer spawn (see delegate.ts / M10).
-// Checked in order of severity: a hard quota wins over a transient rate-limit / overload.
-const QUOTA = /quota|usage limit|resource_exhausted|insufficient_quota/i;
-const RATE = /\b429\b|rate[\s_-]?limit|too many requests/i;
-const OVERLOAD = /overloaded|server is busy|try again later|\b529\b/i;
-function parseRetryAfter(text) {
-    const m = text.match(/retry[\s-]?after[:\s]+(\d+)/i) ?? text.match(/try again in (\d+)\s*(seconds?|secs?|minutes?|mins?)/i);
-    if (!m)
-        return undefined;
-    const n = Number(m[1]);
-    if (!Number.isFinite(n))
-        return undefined;
-    const unit = (m[2] ?? 's').toLowerCase();
-    return unit.startsWith('min') ? n * 60 : n;
-}
-/** Classify a single agent's output. `exhausted` is the failover trigger. */
-export function detectQuotaSignal(agent, output) {
-    const text = output ?? '';
-    let kind;
-    if (QUOTA.test(text))
-        kind = 'quota';
-    else if (RATE.test(text))
-        kind = 'rate-limit';
-    else if (OVERLOAD.test(text))
-        kind = 'overloaded';
-    return { agent, exhausted: kind !== undefined, kind, retryAfterSec: parseRetryAfter(text) };
-}
+// Reactive quota detection (F-ROLE-3). Parse a CLI's stderr/output for rate-limit / quota /
+// overload signals so the orchestrator can fail over to another agent. This is NOT "bypassing
+// limits" — it routes work within each subscription's normal use. Pure + fixture-tested; the
+// live capture of `output` (a real CLI run) is the B-layer spawn (see delegate.ts / M10).
+// Checked in order of severity: a hard quota wins over a transient rate-limit / overload.
+const QUOTA = /quota|usage limit|resource_exhausted|insufficient_quota/i;
+const RATE = /\b429\b|rate[\s_-]?limit|too many requests/i;
+const OVERLOAD = /overloaded|server is busy|try again later|\b529\b/i;
+function parseRetryAfter(text) {
+    const m = text.match(/retry[\s-]?after[:\s]+(\d+)/i) ?? text.match(/try again in (\d+)\s*(seconds?|secs?|minutes?|mins?)/i);
+    if (!m)
+        return undefined;
+    const n = Number(m[1]);
+    if (!Number.isFinite(n))
+        return undefined;
+    const unit = (m[2] ?? 's').toLowerCase();
+    return unit.startsWith('min') ? n * 60 : n;
+}
+/** Classify a single agent's output. `exhausted` is the failover trigger. */
+export function detectQuotaSignal(agent, output) {
+    const text = output ?? '';
+    let kind;
+    if (QUOTA.test(text))
+        kind = 'quota';
+    else if (RATE.test(text))
+        kind = 'rate-limit';
+    else if (OVERLOAD.test(text))
+        kind = 'overloaded';
+    return { agent, exhausted: kind !== undefined, kind, retryAfterSec: parseRetryAfter(text) };
+}