zames_pro 2.71.0 → 2.72.0

package/dist/browser.js

@@ -1,7 +1,8 @@
 import { chromium, } from 'playwright';
 import { extractAnswer, extractTokenUsage, dumpNetBody, isFinishedWithoutAnswer, } from './net-capture.js';
 import { rewriteFailedAttachments } from './commands.js';
-import { CHAT_URL, CHAT_ID_RE, chatUrl, HISTORY_MESSAGES_URL, BUTTON_CLASS_RE, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, CONTINUE_NAME_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, RESTORE_ANSWER_SELECTORS, ASSISTANT_CLASS_RE, ASSISTANT_SELECTOR, ANSWER_MARKDOWN_SELECTOR, MARKDOWN_SELECTOR, CHAT_SIGNAL_NODES_SELECTOR, NEW_CHAT_SELECTOR, NEW_CHAT_TEXT_RE, PASSWORD_SELECTORS, LOGIN_SELECTORS, LOGIN_SUBMIT_SELECTORS, LOGIN_BUTTON_SELECTOR, LOGIN_NAME_RE, LOGIN_FORM_SUBMIT_RE, SIDEBAR_TOGGLE_SELECTORS, TOGGLE_SELECTORS, DEEP_THINKING_RE, WEB_SEARCH_RE, ATTACH_SELECTORS, STATUS_RE, RATE_LIMIT_RE, SERVER_BUSY_RE, GENERATION_ERR_RE, INCOMPLETE_STATUS_RE, ANSWER_URL_RE, } from './deepseek-ui.js';
+import { parseHistoryMessages, extractChatMessages, scrapeChatList, scrapeChatMessages, } from './browser-chats.js';
+import { CHAT_URL, CHAT_ID_RE, chatUrl, HISTORY_MESSAGES_URL, BUTTON_CLASS_RE, INPUT_SELECTORS, SEND_SELECTORS, STOP_SELECTORS, STOP_NAME_RE, CONTINUE_NAME_RE, ANSWER_SELECTORS, THINK_CLASS_RE, MESSAGE_CONTAINER_SELECTORS, RESTORE_ANSWER_SELECTORS, ASSISTANT_CLASS_RE, ASSISTANT_SELECTOR, ANSWER_MARKDOWN_SELECTOR, MARKDOWN_SELECTOR, CHAT_SIGNAL_NODES_SELECTOR, NEW_CHAT_SELECTOR, NEW_CHAT_TEXT_RE, PASSWORD_SELECTORS, LOGIN_SELECTORS, LOGIN_SUBMIT_SELECTORS, LOGIN_BUTTON_SELECTOR, LOGIN_NAME_RE, LOGIN_FORM_SUBMIT_RE, SIDEBAR_TOGGLE_SELECTORS, TOGGLE_SELECTORS, DEEP_THINKING_RE, WEB_SEARCH_RE, ATTACH_SELECTORS, STATUS_RE, ANSWER_URL_RE, } from './deepseek-ui.js';
 import { probeUiHealth, } from './ui-health.js';
 import path from 'path';
 import os from 'os';
@@ -13,234 +14,12 @@ import { translate, DEFAULT_LOCALE } from './i18n.js';
 // here preserves the existing public API (test/*.test.ts import them from
 // browser.ts).
 export { STOP_NAME_RE, CONTINUE_NAME_RE };
-// Muted terminal input for passwords. We do NOT use readline here: readline
-// echoes the typed text through its own internal _writeToOutput, which cannot
-// be reliably overridden from outside (a real bug: the login prompt swallowed
-// the password step). Instead we read raw keystrokes from stdin and echo one
-// `*` per typed character. In a non-TTY (pipe/redirect) we fall back to a
-// plain line read.
-export function askPassword(question) {
-    return new Promise((resolve) => {
-        process.stdout.write(question);
-        // Non-interactive: read a single line from stdin as-is.
-        if (!process.stdin.isTTY) {
-            void import('readline').then(({ createInterface }) => {
-                const rl = createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                });
-                rl.question('', (answer) => {
-                    rl.close();
-                    resolve(answer);
-                });
-            });
-            return;
-        }
-        const stdin = process.stdin;
-        const wasRaw = stdin.isRaw;
-        stdin.setRawMode(true);
-        stdin.resume();
-        let value = '';
-        const onData = (buf) => {
-            const s = buf.toString('utf8');
-            for (const ch of s) {
-                const code = ch.charCodeAt(0);
-                // Enter / Ctrl+J -> done.
-                if (ch === '\r' || ch === '\n') {
-                    done();
-                    return;
-                }
-                // Ctrl+C -> abort the whole process (same as elsewhere in the CLI).
-                if (code === 3) {
-                    cleanup();
-                    process.stdout.write('\n');
-                    process.exit(130);
-                }
-                // Ctrl+D -> finish with whatever we have.
-                if (code === 4) {
-                    done();
-                    return;
-                }
-                // Backspace (0x7f or 0x08): remove the last char and one star.
-                if (code === 127 || code === 8) {
-                    if (value.length > 0) {
-                        value = value.slice(0, -1);
-                        process.stdout.write('\b \b');
-                    }
-                    continue;
-                }
-                // Ignore other control characters (arrows, etc.).
-                if (code < 32)
-                    continue;
-                value += ch;
-                process.stdout.write('*');
-            }
-        };
-        const cleanup = () => {
-            stdin.removeListener('data', onData);
-            try {
-                stdin.setRawMode(wasRaw || false);
-            }
-            catch { }
-            stdin.pause();
-        };
-        const done = () => {
-            cleanup();
-            process.stdout.write('\n');
-            resolve(value);
-        };
-        stdin.on('data', onData);
-    });
-}
-const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile');
-// Cache of the sanitized (non-Headless) User-Agent, keyed by the browser
-// engine path. On the FIRST headless run we detect the real UA, strip the
-// "Headless" marker and store it here; later runs pass it straight to
-// _launchOnce, so the browser starts with a good UA and the "launch → read UA →
-// relaunch" dance happens only once (it otherwise doubled every headless
-// start). Keying by the executable path means a Playwright update (new engine
-// path) invalidates the cache and we re-derive the UA once for the new build.
-const HEADLESS_UA_CACHE = path.join(os.homedir(), '.zames', 'headless-ua.json');
-// Pure: pick a reusable UA from the cache file's text for the given engine, or
-// null. Exported so the policy is unit-tested without touching ~/.zames.
-export function parseHeadlessUACache(raw, engine) {
-    try {
-        const j = JSON.parse(raw);
-        if (j &&
-            j.engine === engine &&
-            typeof j.ua === 'string' &&
-            j.ua &&
-            !/Headless/i.test(j.ua)) {
-            return j.ua;
-        }
-    }
-    catch { }
-    return null;
-}
-function headlessEngineKey() {
-    try {
-        return chromium.executablePath();
-    }
-    catch {
-        return '';
-    }
-}
-async function readCachedHeadlessUA(engine) {
-    if (!engine)
-        return null;
-    try {
-        const raw = await fs.readFile(HEADLESS_UA_CACHE, 'utf-8');
-        return parseHeadlessUACache(raw, engine);
-    }
-    catch {
-        return null;
-    }
-}
-async function writeCachedHeadlessUA(engine, ua) {
-    if (!engine || !ua)
-        return;
-    try {
-        await fs.mkdir(path.dirname(HEADLESS_UA_CACHE), { recursive: true });
-        await fs.writeFile(HEADLESS_UA_CACHE, JSON.stringify({ engine, ua }, null, 2), 'utf-8');
-    }
-    catch { }
-}
-// For /doctor: is a sanitized UA cached for the CURRENT engine build? A missing
-// cache only means the next headless start relaunches once (not an error), so
-// this is informational. Best-effort.
-export async function headlessUACacheReady() {
-    const ua = await readCachedHeadlessUA(headlessEngineKey());
-    return !!ua;
-}
-// A headless Chrome advertises "HeadlessChrome/..." in its User-Agent, and
-// DeepSeek's CDN (CloudFront/WAF) rejects that UA with a plain "403 ERROR"
-// page before the app is even served — so a headless login looked broken while
-// a headed one worked (headed Chrome sends "Chrome/..."). We keep the real
-// engine version and only drop the "Headless" marker. When the operator
-// explicitly set a UA in the config, that one wins (see _launchOnce).
-export function sanitizeHeadlessUA(ua) {
-    return String(ua || '').replace(/HeadlessChrome/g, 'Chrome');
-}
-// Written after a successful sign-in so the next launch knows a session was
-// stored in the persistent profile (used by /doctor and diagnostics).
-const AUTH_MARKER_FILE = path.join(os.homedir(), '.zames', 'auth.json');
-export function isGenerationIncompleteText(text) {
-    const t = String(text || '');
-    return GENERATION_ERR_RE.test(t) || INCOMPLETE_STATUS_RE.test(t);
-}
-export function isRateLimitText(text) {
-    return RATE_LIMIT_RE.test(String(text || ''));
-}
-export function isServerBusyText(text) {
-    const t = String(text || '');
-    // Rate limit takes priority (it needs the long wait).
-    if (RATE_LIMIT_RE.test(t))
-        return false;
-    return SERVER_BUSY_RE.test(t);
-}
-// Normalize text for comparison: collapse whitespace so that tiny DOM
-// differences (nbsp, trailing spaces) don't count as "a new answer".
-export function normText(s) {
-    return String(s || '')
-        .replace(/\u00a0/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-// The "too frequent" error: distinct from others so ask() waits a long time
-// (DeepSeek limits reset over minutes) and retries the send itself.
-export class RateLimitError extends Error {
-    constructor(detail) {
-        super('Messages too frequent. Try again later. ' + detail);
-        this.name = 'RateLimitError';
-    }
-}
-// DeepSeek transient server error (Server busy).
-export class ServerBusyError extends Error {
-    constructor(detail) {
-        super('Server busy. Try again later. ' + detail);
-        this.name = 'ServerBusyError';
-    }
-}
-// The generation was truncated by the server (`generation_err` / INCOMPLETE).
-// Distinct from ServerBusyError: the DeepSeek backend answered, but the turn
-// did not finish, and the UI offers a "Continue" button. The agent retries the
-// same send (a new message into the chat) instead of waiting for an answer
-// that will never arrive. This is what the operator hit with the reasoning
-// (deep thinking) mode on: the long THINK phase makes the truncation far more
-// likely, so with thinking off everything worked and with it on the turn kept
-// stopping and showing "Continue".
-export class GenerationIncompleteError extends Error {
-    constructor(detail) {
-        super('Generation incomplete (server truncated the answer). ' + detail);
-        this.name = 'GenerationIncompleteError';
-    }
-}
-// ---------- profile cleanup ----------
-async function cleanSingletonFiles() {
-    const names = ['SingletonLock', 'SingletonCookie', 'SingletonSocket'];
-    for (const name of names) {
-        const p = path.join(USER_DATA_DIR, name);
-        try {
-            await fs.unlink(p);
-        }
-        catch { }
-    }
-}
-async function profileLooksLocked() {
-    try {
-        await fs.access(path.join(USER_DATA_DIR, 'SingletonLock'));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function nukeProfile() {
-    try {
-        await fs.rm(USER_DATA_DIR, { recursive: true, force: true });
-    }
-    catch { }
-}
+// The pure, state-free helpers live in browser-pure.ts (BACKLOG C3): they are
+// imported for the class below and RE-EXPORTED here, so the public API of this
+// module is unchanged (tests and other modules import these names from
+// './browser.js').
+import { askPassword, USER_DATA_DIR, parseHeadlessUACache, headlessEngineKey, readCachedHeadlessUA, writeCachedHeadlessUA, headlessUACacheReady, sanitizeHeadlessUA, AUTH_MARKER_FILE, isGenerationIncompleteText, isRateLimitText, isServerBusyText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, cleanSingletonFiles, profileLooksLocked, nukeProfile, } from './browser-pure.js';
+export { askPassword, parseHeadlessUACache, headlessUACacheReady, sanitizeHeadlessUA, isGenerationIncompleteText, isRateLimitText, isServerBusyText, normText, RateLimitError, ServerBusyError, GenerationIncompleteError, };
 export class DeepSeekBrowser {
     headless;
     debug;
@@ -2605,31 +2384,9 @@ export class DeepSeekBrowser {
     }
     async listChats(limit = 30) {
         await this._ensureSidebarOpen();
-        return await this.page.evaluate((lim) => {
-            const out = [];
-            const seen = new Set();
-            const anchors = document.querySelectorAll('a[href*="/chat/"]');
-            for (const a of anchors) {
-                const href = a.getAttribute('href') || '';
-                const m = href.match(/\/chat\/s\/([a-zA-Z0-9_-]+)/) ||
-                    href.match(/\/a\/chat\/s\/([a-zA-Z0-9_-]+)/);
-                if (!m)
-                    continue;
-                const id = m[1];
-                if (seen.has(id))
-                    continue;
-                seen.add(id);
-                const titleEl = a.querySelector('[class*="title"], [class*="text"]');
-                let title = (titleEl ? titleEl.textContent : a.textContent) || '';
-                title = title.trim().replace(/\s+/g, ' ');
-                if (!title)
-                    title = '(без названия)';
-                out.push({ id, title, href });
-                if (out.length >= lim)
-                    break;
-            }
-            return out;
-        }, limit);
+        // The scraper is a named export (browser-chats.ts) so the class stays thin
+        // and the scraping policy has one home; it runs inside the page.
+        return await this.page.evaluate(scrapeChatList, limit);
     }
     async openChat(id) {
         // Click the chat link and VERIFY the URL actually points at the
@@ -2696,6 +2453,11 @@ export class DeepSeekBrowser {
         }
         const auth = this._apiAuth;
         const pow = this._apiPow;
+        // The in-page fetch only RETURNS the raw chat_messages; the parsing happens
+        // OUTSIDE, in the pure parseHistoryMessages() (browser-chats.ts), so the
+        // in-page and the Playwright-request fallback paths share ONE parser and
+        // cannot drift. The in-page callback cannot call our helpers (it runs in
+        // the page context), so it must stay a plain data fetch.
         const res = await this.page
             .evaluate(async (opts) => {
             try {
@@ -2714,53 +2476,35 @@ export class DeepSeekBrowser {
                     headers,
                 });
                 if (!resp.ok)
-                    return { error: 'HTTP ' + resp.status, list: [] };
+                    return { error: 'HTTP ' + resp.status, messages: null };
                 const json = await resp.json();
                 const messages = json && json.data && json.data.biz_data
                     ? json.data.biz_data.chat_messages
                     : null;
                 if (!Array.isArray(messages)) {
-                    return { error: 'no chat_messages in response', list: [] };
+                    return { error: 'no chat_messages in response', messages: null };
                 }
-                const NL = String.fromCharCode(10);
-                const out = [];
-                // The context size: the LATEST accumulated_token_usage in the chat
-                // (each message carries the running counter).
-                let usage = null;
-                for (const m of messages) {
-                    if (m && typeof m.accumulated_token_usage === 'number') {
-                        usage = m.accumulated_token_usage;
-                    }
-                    const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
-                    const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
-                    let text = '';
-                    for (const fr of (m && m.fragments) || []) {
-                        if (!fr || fr.type !== want)
-                            continue;
-                        if (typeof fr.content === 'string')
-                            text += fr.content;
-                    }
-                    text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
-                    if (text)
-                        out.push({ role, text });
-                }
-                return { error: '', list: out, usage };
+                return { error: '', messages };
             }
             catch (e) {
-                return { error: 'fetch failed: ' + e.message, list: [] };
+                return {
+                    error: 'fetch failed: ' + e.message,
+                    messages: null,
+                };
             }
         }, { chatId: id, auth, pow, historyUrl: HISTORY_MESSAGES_URL })
             .catch((e) => ({
             error: 'evaluate failed: ' + e.message,
-            list: [],
+            messages: null,
         }));
         this._lastHistoryError = res?.error || '';
+        // Parse the raw messages with the SAME pure parser the fallback uses.
+        const parsed = parseHistoryMessages(res?.messages);
         // Pick up the context size the history carries, so /resume (and /cost
         // right after it) shows a real number even before the first answer.
-        const usage = res?.usage;
-        if (typeof usage === 'number')
-            this._lastTokenUsage = usage;
-        const list = (res?.list || []);
+        if (typeof parsed.usage === 'number')
+            this._lastTokenUsage = parsed.usage;
+        const list = parsed.list;
         if (list.length || !res?.error)
             return list;
         // Fallback: Playwright's own request context (shares the browser cookies)
@@ -2770,31 +2514,17 @@ export class DeepSeekBrowser {
             const resp = await this.page.request.get(HISTORY_MESSAGES_URL + '?chat_session_id=' + encodeURIComponent(id), { headers: { accept: 'application/json' } });
             if (!resp.ok())
                 return list;
-            const json = (await resp.json());
-            const messages = json?.data?.biz_data?.chat_messages;
-            if (!Array.isArray(messages))
+            const json = await resp.json();
+            const messages = extractChatMessages(json);
+            if (!messages)
                 return list;
-            const NL = String.fromCharCode(10);
-            const out = [];
-            for (const m of messages) {
-                if (m && typeof m.accumulated_token_usage === 'number') {
-                    this._lastTokenUsage = m.accumulated_token_usage;
-                }
-                const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
-                const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
-                let text = '';
-                for (const fr of (m && m.fragments) || []) {
-                    if (!fr || fr.type !== want)
-                        continue;
-                    if (typeof fr.content === 'string')
-                        text += fr.content;
-                }
-                text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
-                if (text)
-                    out.push({ role, text });
-            }
+            // Same pure parser as the in-page path (browser-chats.ts), so the two
+            // cannot drift.
+            const parsed = parseHistoryMessages(messages);
+            if (typeof parsed.usage === 'number')
+                this._lastTokenUsage = parsed.usage;
             this._lastHistoryError = '';
-            return out;
+            return parsed.list;
         }
         catch (e) {
             this._lastHistoryError = 'request failed: ' + e.message;
@@ -2810,92 +2540,17 @@ export class DeepSeekBrowser {
     // ds-assistant-message-* class; anything that is not an assistant block is
     // treated as a user message. The model's reasoning (.ds-think-content) is
     // skipped, exactly like in _readLastAnswerText.
+    // Read the WHOLE visible dialogue of the currently open chat, top to
+    // bottom. Used by /resume and /resume-id so the operator sees the restored
+    // context in the terminal instead of just "Chat opened.".
+    //
+    // The in-page scraper (scrapeChatMessages, browser-chats.ts) is a named
+    // export so the class body stays thin; it runs inside the page.
     async readChatMessages() {
         if (!this.page)
             return [];
         const raw = await this.page
-            .evaluate((opts) => {
-            const think = new RegExp(opts.thinkRe, 'i');
-            const assistantRe = new RegExp(opts.assistantRe, 'i');
-            const inThink = (e) => {
-                let n = e;
-                while (n) {
-                    const cls = (n.className || '').toString();
-                    if (think.test(cls))
-                        return true;
-                    n = n.parentElement;
-                }
-                return false;
-            };
-            const textOf = (e) => {
-                const h = e;
-                const t = h.innerText || h.textContent || '';
-                const NL = String.fromCharCode(10);
-                return t.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
-            };
-            // A message block is "assistant" when it contains an answer markdown
-            // wrapper (ds-markdown / ds-assistant-message), otherwise it is a
-            // user bubble. DeepSeek's class names drift between builds, so the
-            // detection is content-based, not class-prefix-based.
-            const looksAssistant = (e) => {
-                const cls = (e.className || '').toString();
-                if (assistantRe.test(cls))
-                    return true;
-                if (e.querySelector(opts.assistantSel))
-                    return true;
-                // A user bubble has no rendered markdown; an answer does.
-                if (e.querySelector(opts.markdownSel))
-                    return true;
-                return false;
-            };
-            // Message-level containers first (broad), then the answer wrappers.
-            // See MESSAGE_CONTAINER_SELECTORS in deepseek-ui.ts.
-            let blocks = [];
-            for (const s of opts.containerSels) {
-                const found = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e) && textOf(e).length > 0);
-                if (found.length) {
-                    blocks = found;
-                    break;
-                }
-            }
-            // De-duplicate by node identity and drop a block that is NESTED
-            // inside another block. Some builds match both an outer message
-            // container and an inner one; without this the restored dialogue
-            // printed each turn twice. We keep only the OUTERMOST blocks.
-            if (blocks.length > 1) {
-                const unique = Array.from(new Set(blocks));
-                blocks = unique.filter((b) => !unique.some((other) => other !== b && other.contains(b)));
-            }
-            const out = [];
-            if (blocks.length) {
-                for (const b of blocks) {
-                    const t = textOf(b);
-                    if (!t)
-                        continue;
-                    out.push({
-                        role: looksAssistant(b) ? 'assistant' : 'user',
-                        text: t,
-                    });
-                }
-                if (out.length)
-                    return out;
-            }
-            // Last resort: assistant answers only (no user turns) — better than
-            // nothing when no message container matched.
-            // See RESTORE_ANSWER_SELECTORS in deepseek-ui.ts.
-            for (const s of opts.answerSels) {
-                const list = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e));
-                if (!list.length)
-                    continue;
-                for (const el of list) {
-                    const t = textOf(el);
-                    if (t)
-                        out.push({ role: 'assistant', text: t });
-                }
-                break;
-            }
-            return out;
-        }, {
+            .evaluate(scrapeChatMessages, {
             containerSels: MESSAGE_CONTAINER_SELECTORS,
             answerSels: RESTORE_ANSWER_SELECTORS,
             thinkRe: THINK_CLASS_RE.source,

package/dist/changelog.js

@@ -78,3 +78,32 @@ export function renderChangelogDraft(groups) {
     }
     return out.join('\n').trimEnd();
 }
+/**
+ * Replace the body between `## [Unreleased]` and the next `## [` heading with
+ * a freshly drafted body (D2). PURE so a test can pin the exact behavior.
+ *
+ * When `body` is empty the existing Unreleased section is CLEARED to just the
+ * heading (no stray blank content). A changelog without an Unreleased heading
+ * is returned UNCHANGED (we never guess where to insert one).
+ */
+export function syncUnreleased(changelog, body) {
+    const nl = '\n';
+    const anchor = '## [Unreleased]';
+    const idx = changelog.indexOf(anchor);
+    if (idx < 0)
+        return changelog;
+    const afterAnchor = idx + anchor.length;
+    // The section ends at the next top-level `## [` (the next version).
+    const rest = changelog.slice(afterAnchor);
+    const next = rest.search(/\n## \[/);
+    const tail = next < 0 ? '' : rest.slice(next);
+    const cleanBody = String(body || '')
+        .replace(/^## \[Unreleased\]\s*/m, '')
+        .trim()
+        // The draft renders groups as `## Added` (top-level), but INSIDE the file
+        // a version's groups are `### Added` (a subsection of the version heading).
+        // `## [` (the next version) is left alone.
+        .replace(/^## (?!\[)/gm, '### ');
+    const section = cleanBody ? nl + nl + cleanBody + nl : nl;
+    return changelog.slice(0, afterAnchor) + section + tail;
+}

package/dist/cli-args.js

@@ -0,0 +1,48 @@
+// PURE CLI argument parsing (BACKLOG C3). index.ts used to hold `args` as a
+// module-level constant plus three helpers closing over it, which made the
+// parsing impossible to unit-test in isolation (index.ts is the entry point and
+// is not covered). `createCliArgs(argv)` binds the argv ONCE and returns the
+// same three helpers, so every call site in index.ts keeps its shape
+// (`getArg('--x')` / `hasFlag('--x')`) while the LOGIC is now pure and tested.
+//
+// Behavior is intentionally identical to the old inline helpers, including the
+// quirk that a value-flag appearing WITHOUT a value returns the fallback (never
+// the flag itself or the next flag).
+// Flags that consume the NEXT argv entry as their value, so the positional
+// parser must skip it. Kept in sync with the getArg call sites by
+// test/cli-flags.test.ts.
+export const SKIP_VALUE_FLAGS = [
+    '--dir',
+    '--task',
+    '--max-iter',
+    '--chat',
+    '--output-format',
+];
+export function createCliArgs(argv) {
+    const args = Array.isArray(argv) ? argv : [];
+    const getArg = (flag, fallback = null) => {
+        const i = args.indexOf(flag);
+        // `args[i + 1]` truthiness means an empty string or a missing value falls
+        // back — the historical behavior (an empty `--task ''` is not a task).
+        // NOTE: this does NOT special-case a following FLAG, so `--task --debug`
+        // returns `--debug` (the original inline helper did the same); we preserve
+        // it rather than "fix" a long-standing quirk in a refactor.
+        return i !== -1 && args[i + 1] ? args[i + 1] : fallback;
+    };
+    const hasFlag = (flag) => args.includes(flag);
+    const getPositional = () => {
+        const positional = [];
+        for (let i = 0; i < args.length; i++) {
+            const a = args[i];
+            if (SKIP_VALUE_FLAGS.includes(a)) {
+                i++;
+                continue;
+            }
+            if (a.startsWith('--'))
+                continue;
+            positional.push(a);
+        }
+        return positional;
+    };
+    return { getArg, hasFlag, getPositional };
+}

package/dist/compact.js

@@ -1,5 +1,6 @@
 import { translate } from './i18n.js';
 import { buildCompactPrompt, buildCompactCarryover, isUsableCompactSummary, trimRestoredMessages, formatRestoredHistory, } from './commands.js';
+import { loadHooks, runLifecycleHooks } from './hooks.js';
 const NL = String.fromCharCode(10);
 /** How many times the summary call is retried before the local fallback. */
 export const COMPACT_SUMMARY_ATTEMPTS = 3;
@@ -42,6 +43,14 @@ export async function performCompact(opts) {
     try {
         if (!quiet)
             log(t('compact.start'));
+        // PreCompact hook (N32): runs BEFORE the chat is summarized/rewritten, so
+        // a hook can persist state or notify. Best-effort.
+        try {
+            const out = await runLifecycleHooks(loadHooks(workdir), 'PreCompact', workdir, { chatId: currentChatId });
+            if (out)
+                transcript?.log('hook_pre_compact', { output: out });
+        }
+        catch { }
         // 1) Ask the OLD chat to summarize itself.
         let summary = '';
         let summaryErr = '';

package/dist/config.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { DEFAULT_DIAGNOSTICS } from './diagnostics.js';
 import { DEFAULT_LOCALE } from './i18n.js';
 import { writeJsonAtomic } from './fsutil.js';
 const ZAMES_HOME = path.join(os.homedir(), '.zames');
@@ -67,7 +68,12 @@ export const DEFAULTS = {
         contextLimit: 1_000_000,
         // 0 = auto: terminal width, capped at 100 columns (the historical width).
         answerWidth: 0,
+        // N37 statusLine hook. Off by default; edit config.json to set a command.
+        statusLineCommand: '',
+        statusLineIntervalMs: 10_000,
     },
+    // Off by default: a full tsc/eslint run after every edit is slow; opt in.
+    diagnostics: { ...DEFAULT_DIAGNOSTICS },
 };
 export function loadConfig() {
     const merged = JSON.parse(JSON.stringify(DEFAULTS));