klyro 1.0.6 → 1.0.7

package/dist/cli/hooks.d.ts

@@ -12,7 +12,13 @@
  * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
  * `matcher` is a regex tested against the tool name — lifecycle events
  * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
- * matcher match every tool.
+ * matcher match every tool; invalid regex never matches.
+ *
+ * Verdict contract: stdout parsed as JSON yields `{decision, message,
+ * context, continue|cont}`. preToolUse `decision:"deny"` blocks with
+ * `message` (wins over exit code); `decision:"allow"` + `context` attaches
+ * model-visible context to the tool result. stop `continue:true` grants one
+ * more turn (max 3/run). Non-JSON stdout keeps pure exit-code semantics.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
@@ -49,6 +55,20 @@ export interface HookResult {
     exitCode: number | null;
     stdout: string;
     stderr: string;
+    /**
+     * Structured verdict parsed from stdout when it is a JSON object
+     * (mirrors CC hook JSON output). Fields:
+     *   - decision: 'allow' | 'deny' (preToolUse; deny wins over exit code)
+     *   - message: denial reason / continuation note
+     *   - context: extra model-visible context (preToolUse allow only)
+     *   - cont: stop-hook request to continue the loop one more turn
+     */
+    verdict?: {
+        decision?: string;
+        message?: string;
+        context?: string;
+        cont?: boolean;
+    };
 }
 export declare const DEFAULT_HOOK_TIMEOUT_MS = 30000;
 /**

package/dist/cli/hooks.js

@@ -12,7 +12,13 @@
  * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
  * `matcher` is a regex tested against the tool name — lifecycle events
  * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
- * matcher match every tool.
+ * matcher match every tool; invalid regex never matches.
+ *
+ * Verdict contract: stdout parsed as JSON yields `{decision, message,
+ * context, continue|cont}`. preToolUse `decision:"deny"` blocks with
+ * `message` (wins over exit code); `decision:"allow"` + `context` attaches
+ * model-visible context to the tool result. stop `continue:true` grants one
+ * more turn (max 3/run). Non-JSON stdout keeps pure exit-code semantics.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
@@ -214,11 +220,13 @@ export function runHook(hook, ctx, stdinJson) {
         });
         child.on('close', (code) => {
             const exitCode = typeof code === 'number' ? code : -1;
+            const out = stdout.slice(0, MAX_HOOK_OUTPUT_CHARS);
             resolve({
                 ok: exitCode === 0,
                 exitCode,
-                stdout: stdout.slice(0, MAX_HOOK_OUTPUT_CHARS),
+                stdout: out,
                 stderr: stderr.slice(0, MAX_HOOK_OUTPUT_CHARS),
+                ...parseVerdict(out),
             });
         });
         // Deliver the stdin JSON contract, then close so the child never hangs
@@ -234,6 +242,30 @@ export function runHook(hook, ctx, stdinJson) {
         catch { /* ignore */ }
     });
 }
+/** Parse a structured JSON verdict from hook stdout (best-effort). */
+function parseVerdict(out) {
+    const trimmed = out.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
+        return {};
+    try {
+        const p = JSON.parse(trimmed);
+        const verdict = {};
+        if (typeof p['decision'] === 'string')
+            verdict.decision = p['decision'];
+        if (typeof p['message'] === 'string')
+            verdict.message = p['message'].slice(0, 2000);
+        if (typeof p['context'] === 'string')
+            verdict.context = p['context'].slice(0, 2000);
+        if (typeof p['continue'] === 'boolean')
+            verdict.cont = p['continue'];
+        if (typeof p['cont'] === 'boolean' && verdict.cont === undefined)
+            verdict.cont = p['cont'];
+        return Object.keys(verdict).length > 0 ? { verdict } : {};
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Run all `sessionEnd` hooks for a finished run (best-effort, sequential).
  * Returns hook outputs for logging. Never throws.

package/dist/cli/keychain.d.ts

@@ -0,0 +1,10 @@
+export declare const KEYCHAIN_SERVICE = "klyro";
+export type KeychainBackend = 'macos' | 'linux';
+/** Which OS backend (if any) can store keys on this machine. */
+export declare function keychainAvailable(): KeychainBackend | null;
+/** Read a secret. Returns null when unavailable, missing, or denied. */
+export declare function keychainGet(account: string): Promise<string | null>;
+/** Store a secret. Returns false when unavailable or denied (caller falls back). */
+export declare function keychainSet(account: string, secret: string): Promise<boolean>;
+/** Delete a secret. Returns false when unavailable (caller falls back). */
+export declare function keychainDelete(account: string): Promise<boolean>;

package/dist/cli/keychain.js

@@ -0,0 +1,86 @@
+/**
+ * OS keychain for provider API keys — no new dependencies, platform CLIs only.
+ *
+ *   - macOS: `security` (Keychain Services; always present)
+ *   - Linux: `secret-tool` (libsecret; present on most GNOME desktops)
+ *   - Windows: unavailable (no dependency-free read path) → file fallback
+ *
+ * Every function is best-effort and never throws: missing CLIs, locked
+ * keychains, and headless sessions all degrade to `null`/`false`, and
+ * callers fall back to the 0600 credentials file. Service name is fixed
+ * (`klyro`), accounts are provider ids (`openai`, `anthropic`).
+ */
+import { execFileSync, spawnSync } from 'node:child_process';
+export const KEYCHAIN_SERVICE = 'klyro';
+/** Which OS backend (if any) can store keys on this machine. */
+export function keychainAvailable() {
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'linux') {
+        try {
+            const r = spawnSync('secret-tool', ['--version'], { stdio: 'ignore', timeout: 5000 });
+            if (r.error)
+                return null;
+            return typeof r.status === 'number' && r.status === 0 ? 'linux' : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function run(args, input) {
+    try {
+        const res = execFileSync(args[0], args.slice(1), {
+            input: input ?? undefined,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 10_000,
+        });
+        return { ok: true, out: typeof res === 'string' ? res : '' };
+    }
+    catch {
+        return { ok: false, out: '' };
+    }
+}
+/** Read a secret. Returns null when unavailable, missing, or denied. */
+export async function keychainGet(account) {
+    const backend = keychainAvailable();
+    if (!backend)
+        return null;
+    if (backend === 'macos') {
+        const r = run(['security', 'find-generic-password', '-s', KEYCHAIN_SERVICE, '-a', account, '-w']);
+        const v = r.out.trim();
+        return r.ok && v ? v : null;
+    }
+    const r = run(['secret-tool', 'lookup', 'service', KEYCHAIN_SERVICE, 'account', account]);
+    const v = r.out.replace(/\n$/, '');
+    return r.ok && v ? v : null;
+}
+/** Store a secret. Returns false when unavailable or denied (caller falls back). */
+export async function keychainSet(account, secret) {
+    if (!secret)
+        return false;
+    const backend = keychainAvailable();
+    if (!backend)
+        return false;
+    if (backend === 'macos') {
+        // -U updates an existing item instead of erroring on duplicates.
+        const r = run(['security', 'add-generic-password', '-U', '-s', KEYCHAIN_SERVICE, '-a', account, '-w', secret]);
+        return r.ok;
+    }
+    const r = run(['secret-tool', 'store', '--label', `klyro ${account}`, 'service', KEYCHAIN_SERVICE, 'account', account], secret);
+    return r.ok;
+}
+/** Delete a secret. Returns false when unavailable (caller falls back). */
+export async function keychainDelete(account) {
+    const backend = keychainAvailable();
+    if (!backend)
+        return false;
+    if (backend === 'macos') {
+        const r = run(['security', 'delete-generic-password', '-s', KEYCHAIN_SERVICE, '-a', account]);
+        return r.ok;
+    }
+    const r = run(['secret-tool', 'clear', 'service', KEYCHAIN_SERVICE, 'account', account]);
+    return r.ok;
+}

package/dist/cli/repl.js

@@ -1188,30 +1188,55 @@ export async function startRepl(opts = {}) {
             }
             case 'rewind': {
                 // Numbered rewind menu: bare /rewind lists snapshots (1 = latest),
-                // /rewind <n> restores, /rewind <n> summary also reports reverted files.
-                const { listCheckpointInfo, undo } = await import('../checkpoints/store.js');
+                // /rewind <n> restores code, /rewind <n> summary adds a revert
+                // report, /rewind <n> preview dry-runs, /rewind <n> full also
+                // truncates the conversation after the snapshot.
+                const { listCheckpointInfo, snapshotFiles, undo } = await import('../checkpoints/store.js');
                 const infos = await listCheckpointInfo(cwd);
                 if (infos.length === 0) {
                     queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'No checkpoints yet — snapshots are taken after each file mutation.', role: 'assistant' });
                     return;
                 }
                 const n = cmd.n ?? 1;
-                if (cmd.n === undefined && !cmd.summary) {
+                const mode = cmd.mode;
+                if (cmd.n === undefined && !mode) {
                     const rows = infos.slice(0, 10).map((c) => {
                         const age = c.ts > 0 ? ` (${Math.max(1, Math.round((Date.now() - c.ts) / 60000))}m ago)` : '';
                         return `  ${c.index}. ${c.id.slice(0, 12)} · ${c.files} file(s)${age}`;
                     });
-                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}\nrun /rewind <n> to restore, /rewind <n> summary for a revert report`, role: 'assistant' });
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}\nrun /rewind <n> to restore, /rewind <n> preview to dry-run, /rewind <n> summary for a revert report, /rewind <n> full to also rewind the conversation`, role: 'assistant' });
                     return;
                 }
                 if (n < 1 || n > infos.length) {
                     queuedAppend({ id: `rewind-err-${Date.now()}`, kind: 'error', message: `rewind failed: only ${infos.length} checkpoint(s), got n=${n}` });
                     return;
                 }
+                const target = infos[n - 1];
+                if (mode === 'preview') {
+                    // Dry run: list what WOULD be restored + current dirty state.
+                    const files = await snapshotFiles(cwd, target.id);
+                    let dirty = '';
+                    try {
+                        const { execFileSync } = await import('node:child_process');
+                        dirty = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 5000 });
+                    }
+                    catch {
+                        dirty = '';
+                    }
+                    const listed = files.slice(0, 20).map((f) => `  ${f}`).join('\n') || '  (no files recorded)';
+                    const dirtyLines = dirty.split('\n').map((l) => l.trim()).filter(Boolean).slice(0, 10);
+                    queuedAppend({
+                        id: `rewind-${Date.now()}`,
+                        kind: 'text',
+                        text: `Preview: /rewind ${n} would restore checkpoint ${target.id.slice(0, 12)}:\n${listed}${files.length > 20 ? `\n  … +${files.length - 20} more` : ''}${dirtyLines.length > 0 ? `\nCurrent dirty files that would be overwritten:\n${dirtyLines.map((f) => `  ${f}`).join('\n')}` : '\nWorking tree is clean.'}\nRun /rewind ${n} to apply.`,
+                        role: 'assistant',
+                    });
+                    return;
+                }
                 try {
                     // Capture the pre-restore dirty state so `summary` can report it.
                     let before = '';
-                    if (cmd.summary) {
+                    if (mode === 'summary' || mode === 'full') {
                         try {
                             const { execFileSync } = await import('node:child_process');
                             before = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 5000 });
@@ -1221,12 +1246,27 @@ export async function startRepl(opts = {}) {
                         }
                     }
                     await undo(cwd, n);
-                    const target = infos[n - 1];
                     let text = `Rewound to checkpoint ${n} (${target.id.slice(0, 12)}, ${target.files} file(s))`;
-                    if (cmd.summary) {
+                    if (mode === 'summary' || mode === 'full') {
                         const files = before.split('\n').map((l) => l.trim()).filter(Boolean).slice(0, 20);
                         text += files.length > 0 ? `\nReverted working-tree changes:\n${files.map((f) => `  ${f}`).join('\n')}` : '\nWorking tree was clean before restore.';
                     }
+                    if (mode === 'full') {
+                        // Conversation rewind: drop persisted messages/observations at
+                        // or after the snapshot, so resume continues from that point.
+                        if (tuiSessionId) {
+                            try {
+                                const removed = await tuiStore.truncateMessages(tuiSessionId, target.ts > 0 ? target.ts : Date.now());
+                                text += `\nConversation rewound: dropped ${removed.messages} message(s), ${removed.observations} observation(s).`;
+                            }
+                            catch (err) {
+                                text += `\nConversation rewind failed (code restored): ${err instanceof Error ? err.message : String(err)}`;
+                            }
+                        }
+                        else {
+                            text += '\nNo active session — code restored, conversation untouched.';
+                        }
+                    }
                     queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text, role: 'assistant' });
                 }
                 catch (err) {
@@ -1709,12 +1749,12 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'auth': {
-                const { getStoredKey } = await import('./auth.js');
-                const rows = ['openai', 'anthropic'].map((p) => {
-                    const hasFile = !!getStoredKey(p);
+                const { getStoredKeyAsync } = await import('./auth.js');
+                const rows = await Promise.all(['openai', 'anthropic'].map(async (p) => {
+                    const hasKeychain = !!(await getStoredKeyAsync(p));
                     const hasEnv = !!(p === 'openai' ? process.env.OPENAI_API_KEY : process.env.ANTHROPIC_API_KEY) || !!process.env.KLYRO_API_KEY;
-                    return `  ${p}: ${hasFile ? 'stored key (0600)' : hasEnv ? 'env key' : '—'}`;
-                });
+                    return `  ${p}: ${hasKeychain ? 'stored key (keychain/file)' : hasEnv ? 'env key' : '—'}`;
+                }));
                 queuedAppend({ id: `auth-${Date.now()}`, kind: 'text', text: `Auth:\n${rows.join('\n')}\ncurrent provider: ${currentProvider}\nmanage via /login /logout`, role: 'assistant' });
                 return;
             }
@@ -2924,12 +2964,9 @@ export async function startRepl(opts = {}) {
                     const pm = /^mcp__([A-Za-z0-9_-]{1,20})__([A-Za-z0-9_-]+)$/.exec(m[1].toLowerCase());
                     if (pm) {
                         const { runMcpPrompt } = await import('../mcp/registry.js');
-                        const argList = m[2] ? m[2].split(/\s+/) : [];
-                        const args = {};
-                        argList.forEach((a, i) => { args[`arg${i + 1}`] = a; });
-                        args['input'] = m[2] ?? '';
+                        const tokens = m[2] ? m[2].split(/\s+/).filter(Boolean) : [];
                         try {
-                            const text = await runMcpPrompt(cwd, pm[1], pm[2], args);
+                            const text = await runMcpPrompt(cwd, pm[1], pm[2], tokens);
                             await runWithBridge(text);
                         }
                         catch (err) {

package/dist/cli/setup.js

@@ -13,7 +13,7 @@
  *
  * The `ask` callback is injected so this is unit-testable without a TTY.
  */
-import { LOGIN_DEFAULTS, getStoredKey, saveKey } from './auth.js';
+import { LOGIN_DEFAULTS, saveKey } from './auth.js';
 import { loadConfig, saveConfig } from './config.js';
 import { assertSafeBaseURL } from '../chat.js';
 function isAbort(err) {
@@ -70,7 +70,8 @@ export async function runFirstRunSetup(ask) {
         const defs = LOGIN_DEFAULTS[name] ?? LOGIN_DEFAULTS.openai;
         const storeProvider = name === 'local' ? 'openai' : name;
         // Reuse an already-saved key when present — don't make the user re-paste.
-        const hasKey = !!getStoredKey(storeProvider);
+        const { getStoredKeyAsync } = await import('./auth.js');
+        const hasKey = !!(await getStoredKeyAsync(storeProvider));
         let key = '';
         if (hasKey) {
             const keep = await ask(`API key already saved for ${storeProvider} — keep it? [Y/n]: `);

package/dist/cli/slash/parser.d.ts

@@ -43,7 +43,7 @@ export type SlashCommand = {
 } | {
     kind: 'rewind';
     n?: number;
-    summary?: boolean;
+    mode?: 'summary' | 'preview' | 'full';
 } | {
     kind: 'checkpoints';
 } | {

package/dist/cli/slash/parser.js

@@ -40,14 +40,17 @@ export function parse(input) {
             return { kind: 'undo', n: Number.isInteger(un) && un > 0 ? un : 1 };
         }
         case 'rewind': {
-            // /rewind [n] [summary] — nth-back snapshot (1 = latest), optional
-            // post-restore summary of the reverted changes.
+            // /rewind [n] [summary|preview|full] — nth-back snapshot (1 = latest).
+            // summary: post-restore revert report; preview: dry-run file list;
+            // full: code restore + truncate conversation after the snapshot.
             const parts = rest.split(/\s+/).filter(Boolean);
             const n = parts.length > 0 ? Number(parts[0]) : 1;
+            const modeWord = parts.slice(1).join(' ').toLowerCase();
+            const mode = modeWord === 'summary' || modeWord === 'preview' || modeWord === 'full' ? modeWord : undefined;
             return {
                 kind: 'rewind',
                 n: Number.isInteger(n) && n > 0 ? n : 1,
-                ...(parts.slice(1).join(' ').toLowerCase() === 'summary' ? { summary: true } : {}),
+                ...(mode ? { mode } : {}),
             };
         }
         case 'checkpoints': return { kind: 'checkpoints' };

package/dist/cli/update.d.ts

@@ -12,4 +12,6 @@
 /** Minimal semver compare for `x.y.z[-prerelease]`; null when unparseable. */
 export declare function compareSemver(a: string, b: string): number | null;
 export declare function checkForUpdate(current: string): Promise<string | null>;
-export declare function runUpdate(): Promise<number>;
+export declare function runUpdate(opts?: {
+    apply?: boolean;
+}): Promise<number>;

package/dist/cli/update.js

@@ -138,7 +138,7 @@ export async function checkForUpdate(current) {
     }
     return null;
 }
-export async function runUpdate() {
+export async function runUpdate(opts = {}) {
     const here = await import('../index.js').then(() => '');
     // Get version from package.json via dynamic import
     const { readFileSync } = await import('node:fs');
@@ -151,6 +151,21 @@ export async function runUpdate() {
         const latest = await checkForUpdate(cur);
         if (latest) {
             process.stdout.write(`Update available: ${cur} → ${latest} (integrity verified)\n  npm i -g klyro@latest\n`);
+            if (opts.apply) {
+                // Opt-in self-apply: the tarball was already hash-verified by
+                // checkForUpdate, so npm installs exactly the verified version.
+                process.stdout.write(`Applying update to klyro@${latest}...\n`);
+                const { spawnSync } = await import('node:child_process');
+                const npmCli = process.env['npm_execpath'];
+                const r = npmCli
+                    ? spawnSync(process.execPath, [npmCli, 'i', '-g', `klyro@${latest}`], { stdio: 'inherit' })
+                    : spawnSync('npm', ['i', '-g', `klyro@${latest}`], { stdio: 'inherit', shell: process.platform === 'win32' });
+                if (r.error) {
+                    process.stderr.write(`klyro update: apply failed: ${r.error.message}\n`);
+                    return 1;
+                }
+                return r.status === 0 ? 0 : 1;
+            }
         }
         else {
             process.stdout.write(`klyro ${cur} is latest\n`);

package/dist/context/accounting.d.ts

@@ -7,6 +7,12 @@ export interface ContextAccounting {
     compactAt: number;
     toolResultMax: number;
 }
+/**
+ * Single output-reserve used by every budget in the harness (displayed
+ * accounting, runtime enforcement, compaction elide). One constant so the
+ * meter and the enforcer can never disagree.
+ */
+export declare const RESERVE_OUTPUT_TOKENS = 8000;
 export declare function accounting(system: string | undefined, messages: Message[], opts?: {
     cap?: number;
     reserveOutput?: number;

package/dist/context/accounting.js

@@ -4,8 +4,14 @@
  */
 import { totalTokens } from './tokenizer.js';
 import { getModelInfo } from '../providers/model-info.js';
+/**
+ * Single output-reserve used by every budget in the harness (displayed
+ * accounting, runtime enforcement, compaction elide). One constant so the
+ * meter and the enforcer can never disagree.
+ */
+export const RESERVE_OUTPUT_TOKENS = 8000;
 export function accounting(system, messages, opts = {}) {
-    const reserveOutput = opts.reserveOutput ?? 16_000;
+    const reserveOutput = opts.reserveOutput ?? RESERVE_OUTPUT_TOKENS;
     // Window-aware default: the legacy 120k ceiling overflows small-window
     // models (e.g. 8k local models) and wastes large ones — size to the model.
     const cap = opts.cap ?? capForModel(opts.model, reserveOutput);
@@ -21,7 +27,7 @@ export function accounting(system, messages, opts = {}) {
  * tiny windows still function. Unknown models use the registry fallback
  * window (100k); a missing model name keeps the legacy 120k.
  */
-export function capForModel(model, reserveOutput = 16_000) {
+export function capForModel(model, reserveOutput = RESERVE_OUTPUT_TOKENS) {
     if (!model)
         return 120_000;
     const window = getModelInfo(model).contextWindow;

package/dist/context/compaction.d.ts

@@ -2,13 +2,14 @@
  * 8.3 — Auto-compaction: (a) elide → (b) summarize 60% with model.small → (c) keep last N verbatim
  * Trigger at compactAt (80%) or /compact [focus]. Validates summary mentions every checkpointed file else fallback.
  */
-import type { Message } from '../agent/message.js';
+import type { Message, ContentBlock } from '../agent/message.js';
 export interface CompactionResult {
     messages: Message[];
     summary: string;
     dropped: number;
     method: 'elide' | 'summarize' | 'fallback';
 }
+export declare function textBlock(s: string): ContentBlock;
 export declare function compact(messages: Message[], opts: {
     system?: string;
     cap?: number;

package/dist/context/compaction.js

@@ -1,14 +1,37 @@
 import { compressTranscript } from './tokenizer.js';
-import { capForModel } from './accounting.js';
+import { capForModel, RESERVE_OUTPUT_TOKENS } from './accounting.js';
+export function textBlock(s) {
+    return { kind: 'text', text: s };
+}
+/**
+ * Tightened checkpoint validation: every checkpointed file must be mentioned
+ * by a path segment, not a loose basename substring. `src/util.ts` is matched
+ * by "util.ts" only when it names a segment; `foo` never matches `foo.png`
+ * nor a path nested inside it.
+ */
+function mentionsFile(summary, filePath) {
+    const segs = filePath.split('/').filter(Boolean);
+    const tail = segs[segs.length - 1] ?? filePath;
+    // Match the full basename OR any path segment borne by the file.
+    // Prefer exact-path segments (src/util.ts or util.ts) to avoid the
+    // substring false-positive the old `includes(basename)` produced.
+    const quoted = filePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const quotedTail = tail.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(^|[\\W_])${quotedTail}([\\W_]|$)`).test(summary) || summary.includes(quoted);
+}
 export async function compact(messages, opts) {
     const cap = opts.cap ?? capForModel(opts.model);
     // (a) elide old tool results
-    const elided = compressTranscript(opts.system, messages, { total: cap, reservedOutput: 16_000 });
+    const elided = compressTranscript(opts.system, messages, { total: cap, reservedOutput: RESERVE_OUTPUT_TOKENS });
     if (opts.checkpointedFiles && elided.dropped > 0) {
-        // (b) try summarize oldest 60% using strict template (mock small model)
-        const n = Math.floor(messages.length * 0.6);
-        const oldest = messages.slice(0, n);
-        const newest = messages.slice(n);
+        // (b) try summarize oldest 60% using strict template (mock small model).
+        // Slice from the ELIDED sequence so the summarize pass operates on what
+        // actually survives elision (previously it sliced the raw `messages`,
+        // silently dropping the elide benefit on the oldest portion).
+        const elidedBest = elided.messages;
+        const n = Math.floor(elidedBest.length * 0.6);
+        const oldest = elidedBest.slice(0, n);
+        const newest = elidedBest.slice(n);
         const template = `Summarize the following ${oldest.length} messages, mentioning every file: ${opts.checkpointedFiles.join(', ')}.\nFocus: ${opts.focus ?? 'general'}\n\n` + oldest.map((m) => JSON.stringify(m.content).slice(0, 500)).join('\n');
         let summary = `Earlier in session: ${oldest.length} turns covering ${opts.checkpointedFiles.join(', ')}`;
         if (opts.summarizeFn) {
@@ -17,24 +40,28 @@ export async function compact(messages, opts) {
             }
             catch { /* fallback */ }
         }
-        // validate: every checkpointed file mentioned
-        const missing = opts.checkpointedFiles.filter((f) => !summary.includes(f.split('/').pop() ?? f));
+        // validate: every checkpointed file mentioned (path-segment match).
+        const missing = opts.checkpointedFiles.filter((f) => !mentionsFile(summary, f));
         if (missing.length === 0) {
-            // (c) keep last N verbatim + summary as first message
-            const summaryMsg = { role: 'user', content: [{ kind: 'text', text: summary }] };
+            // (c) keep last N verbatim + summary as first message (typed block).
+            const summaryMsg = { role: 'user', content: [textBlock(summary)] };
             return { messages: [summaryMsg, ...newest], summary, dropped: elided.dropped, method: 'summarize' };
         }
         // retry once then fallback to elide
         if (opts.summarizeFn) {
             try {
                 const retry = await opts.summarizeFn(template + '\nEnsure to mention: ' + missing.join(', '));
-                if (missing.every((f) => retry.includes(f.split('/').pop() ?? f))) {
-                    const summaryMsg2 = { role: 'user', content: [{ kind: 'text', text: retry }] };
+                if (missing.every((f) => mentionsFile(retry, f))) {
+                    const summaryMsg2 = { role: 'user', content: [textBlock(retry)] };
                     return { messages: [summaryMsg2, ...newest], summary: retry, dropped: elided.dropped, method: 'summarize' };
                 }
             }
             catch { /* fallback */ }
         }
     }
+    // Post-check the elide path too: if it still exceeds cap, keep eliding.
+    if (elided.dropped === 0) {
+        return { messages, summary: '', dropped: 0, method: 'fallback' };
+    }
     return { messages: elided.messages, summary: elided.dropped > 0 ? `Elided ${elided.dropped} observations` : '', dropped: elided.dropped, method: elided.dropped > 0 ? 'elide' : 'fallback' };
 }

package/dist/context/memory.d.ts

@@ -3,6 +3,17 @@ import type { PlanStep } from '../agent/runtime.js';
 export declare const MEMORY_WRITE_LIMIT_CHARS = 8000;
 /** Steady-state cap (~1k tokens ≈ 4k chars) kept via tail slice. */
 export declare const MEMORY_STEADY_STATE_CHARS = 4000;
+/** Archive index filename (recall without an LLM pass). */
+export declare const MEMORY_ARCHIVE_INDEX = "archive-index.json";
+/** Max retained archives. */
+export declare const MEMORY_ARCHIVE_KEEP = 20;
+export interface MemoryArchiveEntry {
+    file: string;
+    ts: number;
+    chars: number;
+    /** First line of the archived head — lets the model decide what to re-read. */
+    preview: string;
+}
 export declare function memoryWrite(cwd: string, content: string): Promise<string>;
 export declare function loadMemory(cwd: string): Promise<string>;
 /** Synchronous read for the system-prompt build path (run on every turn). */