sanook-cli 0.5.0 → 0.5.2

package/dist/brain-review.js

@@ -0,0 +1,382 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listFinalGateFiles, validateFinalGateContent } from './brain-final.js';
+import { normalize } from './memory-store.js';
+import { INDEX_PATH, sanitizeManifest } from './search/store.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_MEMORY_INBOX_MAX_AGE_DAYS = 14;
+const DEFAULT_CONTEXT_PACK_MAX_AGE_DAYS = 90;
+const DEFAULT_EVAL_FRESHNESS_TOLERANCE_MS = 60 * 1000;
+const DETAIL_LIMIT = 25;
+const ROOT_FILES_WITHOUT_UP = new Set(['Home.md', 'README.md', 'CLAUDE.md', 'GEMINI.md', 'AGENTS.md', 'SANOOK.md']);
+const ROOT_FILES_WITHOUT_PARENT = ROOT_FILES_WITHOUT_UP;
+const SKIP_DIRS = new Set(['.git', '.obsidian', 'node_modules', 'Shared/Context7-Docs']);
+const NEGATION_TOKENS = new Set([
+    'no',
+    'not',
+    'never',
+    'without',
+    'disable',
+    'disabled',
+    'false',
+    'ไม่',
+    'ห้าม',
+    'เลิก',
+    'ปิด',
+    'ไม่ได้',
+    'ไม่ชอบ',
+]);
+export function parseBrainReviewArgs(args) {
+    let scanMarkdownHygiene = true;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--no-hygiene') {
+            scanMarkdownHygiene = false;
+        }
+        else if (a === '--hygiene') {
+            scanMarkdownHygiene = true;
+        }
+        else {
+            return { ok: false, message: `ไม่รู้จัก option: ${a}` };
+        }
+    }
+    return { ok: true, value: { scanMarkdownHygiene } };
+}
+function result(id, title, findings, message, fail = false, path) {
+    const status = fail ? 'fail' : findings.length ? 'warn' : 'pass';
+    return { id, title, status, message, path, findings: findings.length ? findings : undefined };
+}
+function normalizeCandidate(line) {
+    return normalize(line.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+}
+function tokensForCandidate(line) {
+    return new Set(normalizeCandidate(line)
+        .split(/\s+/)
+        .filter((token) => token.length > 1 && !NEGATION_TOKENS.has(token)));
+}
+function hasNegation(line) {
+    const normalized = normalizeCandidate(line);
+    return [...NEGATION_TOKENS].some((token) => normalized.includes(token));
+}
+function sectionBullets(content, heading) {
+    const lines = content.split('\n');
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading.toLowerCase()}`);
+    if (start < 0)
+        return [];
+    const out = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{1,6}\s+/.test(line.trim()))
+            break;
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && !trimmed.includes('_('))
+            out.push(trimmed);
+    }
+    return out;
+}
+function overlap(a, b) {
+    if (!a.size || !b.size)
+        return 0;
+    let shared = 0;
+    for (const token of a)
+        if (b.has(token))
+            shared++;
+    return shared / Math.min(a.size, b.size);
+}
+async function pathExistsAsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function mtimeMs(path) {
+    try {
+        return (await stat(path)).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+async function listMarkdown(root) {
+    const out = [];
+    async function walk(abs, rel) {
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name) || SKIP_DIRS.has(childRel))
+                    continue;
+                await walk(join(abs, entry.name), childRel);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(childRel);
+            }
+        }
+    }
+    await walk(root, '');
+    return out.sort();
+}
+async function readManifest(indexPath) {
+    try {
+        const raw = JSON.parse(await readFile(indexPath, 'utf8'));
+        return sanitizeManifest(raw.manifest);
+    }
+    catch {
+        return null;
+    }
+}
+async function checkMemoryInbox(brainPath, nowMs, maxAgeDays) {
+    const path = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const content = await readText(path);
+    if (!content) {
+        return result('review.memory-inbox', 'Memory-Inbox curation', [{ message: 'Memory-Inbox file is missing.', path }], 'Memory-Inbox is missing.', true, path);
+    }
+    const candidates = [...sectionBullets(content, 'New Candidates'), ...sectionBullets(content, 'Needs Merge')];
+    const findings = [];
+    const seen = new Map();
+    const duplicates = [];
+    for (const candidate of candidates) {
+        const key = normalizeCandidate(candidate);
+        if (!key)
+            continue;
+        if (seen.has(key))
+            duplicates.push(candidate);
+        else
+            seen.set(key, candidate);
+    }
+    if (duplicates.length) {
+        findings.push({ message: `${duplicates.length} duplicate Memory-Inbox candidate(s).`, path, details: duplicates.slice(0, DETAIL_LIMIT) });
+    }
+    const needsMerge = sectionBullets(content, 'Needs Merge');
+    if (needsMerge.length) {
+        findings.push({ message: `${needsMerge.length} Memory-Inbox item(s) are waiting in Needs Merge.`, path, details: needsMerge.slice(0, DETAIL_LIMIT) });
+    }
+    const possibleContradictions = [];
+    for (let i = 0; i < candidates.length; i++) {
+        for (let j = i + 1; j < candidates.length; j++) {
+            if (hasNegation(candidates[i]) === hasNegation(candidates[j]))
+                continue;
+            const score = overlap(tokensForCandidate(candidates[i]), tokensForCandidate(candidates[j]));
+            if (score >= 0.6)
+                possibleContradictions.push(`${candidates[i]} <> ${candidates[j]}`);
+        }
+    }
+    if (possibleContradictions.length) {
+        findings.push({
+            message: `${possibleContradictions.length} possible contradictory Memory-Inbox pair(s).`,
+            path,
+            details: possibleContradictions.slice(0, DETAIL_LIMIT),
+        });
+    }
+    const ageDays = Math.floor((nowMs - (await mtimeMs(path))) / DAY_MS);
+    if (candidates.length && ageDays > maxAgeDays) {
+        findings.push({ message: `Memory-Inbox has ${candidates.length} candidate(s) and was last touched ${ageDays} days ago.`, path });
+    }
+    return result('review.memory-inbox', 'Memory-Inbox curation', findings, candidates.length ? `${candidates.length} candidate(s) reviewed.` : 'Memory-Inbox has no active candidates.', false, path);
+}
+async function checkContextPacks(brainPath, nowMs, maxAgeDays) {
+    const dir = join(brainPath, 'Shared', 'Context-Packs');
+    const indexPath = join(dir, '_Index.md');
+    const index = await readText(indexPath);
+    const findings = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return result('review.context-packs', 'Context pack curation', [{ message: 'Context-Packs directory is missing.', path: dir }], 'Context-Packs directory is missing.', true, dir);
+    }
+    if (!index)
+        findings.push({ message: 'Context-Packs index is missing.', path: indexPath });
+    const packs = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name !== '_Index.md');
+    for (const pack of packs) {
+        const path = join(dir, pack.name);
+        const content = await readText(path);
+        const missingSections = ['## Load Order', '## Done Criteria'].filter((section) => !content.includes(section));
+        if (missingSections.length) {
+            findings.push({ message: `${pack.name} is missing expected section(s).`, path, details: missingSections });
+        }
+        const link = `[[Shared/Context-Packs/${pack.name.replace(/\.md$/i, '')}]]`;
+        if (index && !index.includes(link))
+            findings.push({ message: `${pack.name} is not linked from Context-Packs index.`, path: indexPath });
+        const ageDays = Math.floor((nowMs - (await mtimeMs(path))) / DAY_MS);
+        if (ageDays > maxAgeDays)
+            findings.push({ message: `${pack.name} has not been touched for ${ageDays} days.`, path });
+    }
+    return result('review.context-packs', 'Context pack curation', findings, packs.length ? `${packs.length} context pack(s) reviewed.` : 'No context packs found.', false, dir);
+}
+async function checkSessionIndexCoverage(brainPath, indexPath) {
+    const sessionsDir = join(brainPath, 'Sessions');
+    let entries;
+    try {
+        entries = await readdir(sessionsDir, { withFileTypes: true });
+    }
+    catch {
+        return result('review.session-index', 'Session index coverage', [{ message: 'Sessions directory is missing.', path: sessionsDir }], 'Sessions directory is missing.', true, sessionsDir);
+    }
+    const sessions = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name !== '_Index.md')
+        .map((entry) => `Sessions/${entry.name}`)
+        .sort();
+    if (!sessions.length)
+        return result('review.session-index', 'Session index coverage', [], 'No session notes to check.', false, sessionsDir);
+    const manifest = await readManifest(indexPath);
+    if (!manifest) {
+        return result('review.session-index', 'Session index coverage', [{ message: 'Search index is missing or unreadable; run `sanook index`.', path: indexPath }], `${sessions.length} session note(s) found, but no readable index manifest exists.`, false, indexPath);
+    }
+    const missing = sessions.filter((session) => !manifest[session]);
+    return result('review.session-index', 'Session index coverage', missing.length ? [{ message: `${missing.length} session note(s) are missing from the search manifest.`, path: indexPath, details: missing.slice(0, DETAIL_LIMIT) }] : [], `${sessions.length} session note(s) checked against the search manifest.`, false, indexPath);
+}
+async function frameworkFiles(brainPath) {
+    const paths = ['SANOOK.md', 'AGENTS.md', 'CLAUDE.md', 'GEMINI.md', 'Vault Structure Map.md', 'Shared/AI-Context-Index.md'];
+    for (const rel of await listMarkdown(join(brainPath, 'Shared', 'Rules')))
+        paths.push(`Shared/Rules/${rel}`);
+    for (const rel of await listMarkdown(join(brainPath, 'Shared', 'Context-Packs')))
+        paths.push(`Shared/Context-Packs/${rel}`);
+    return paths;
+}
+async function newest(paths, brainPath) {
+    let best = { rel: '', mtime: 0 };
+    for (const rel of paths) {
+        const mt = await mtimeMs(join(brainPath, rel));
+        if (mt > best.mtime)
+            best = { rel, mtime: mt };
+    }
+    return best;
+}
+async function checkEvalFreshness(brainPath, toleranceMs) {
+    const evalFiles = ['Evals/second-brain-benchmarks.md', 'Evals/retrieval-eval.md', 'Evals/quality-ledger.md'];
+    const findings = [];
+    for (const rel of evalFiles) {
+        if (!(await mtimeMs(join(brainPath, rel))))
+            findings.push({ message: `Missing eval file: ${rel}`, path: join(brainPath, rel) });
+    }
+    if (findings.length) {
+        return result('review.eval-freshness', 'Eval freshness after framework changes', findings, 'Eval files are incomplete.', true, join(brainPath, 'Evals'));
+    }
+    const newestFramework = await newest(await frameworkFiles(brainPath), brainPath);
+    const newestEval = await newest(evalFiles, brainPath);
+    if (newestFramework.mtime > newestEval.mtime + toleranceMs) {
+        findings.push({
+            message: 'Framework/context files are newer than eval evidence; rerun `sanook brain eval` and update the ledger if behavior changed.',
+            details: [`newest framework: ${newestFramework.rel}`, `newest eval: ${newestEval.rel}`],
+        });
+    }
+    return result('review.eval-freshness', 'Eval freshness after framework changes', findings, 'Framework files and eval evidence compared.', false, join(brainPath, 'Evals'));
+}
+async function checkFinalGates(brainPath) {
+    const findings = [];
+    for (const rel of ['Templates/final.md', 'Templates/final-lite.md']) {
+        const content = await readText(join(brainPath, rel));
+        if (!content) {
+            findings.push({ message: `Missing final gate template: ${rel}`, path: join(brainPath, rel) });
+            continue;
+        }
+        const missing = ['## 1. Objective / DoD Lock', '## 4. Evidence Matrix', '## Final Verdict'].filter((section) => !content.includes(section));
+        if (missing.length)
+            findings.push({ message: `${rel} is missing expected final gate section(s).`, path: join(brainPath, rel), details: missing });
+    }
+    const gates = await listFinalGateFiles(brainPath);
+    for (const gate of gates) {
+        const validation = validateFinalGateContent(gate.content);
+        if (!validation.ok) {
+            findings.push({
+                message: `${gate.relPath} has incomplete final gate evidence.`,
+                path: gate.path,
+                details: validation.warnings.slice(0, DETAIL_LIMIT),
+            });
+        }
+    }
+    return result('review.final-gates', 'Final gate evidence', findings, gates.length ? `${gates.length} final gate note(s) checked.` : 'Final gate templates checked; no session final gates found.', false, join(brainPath, 'Templates'));
+}
+async function checkMarkdownHygiene(brainPath) {
+    const markdown = await listMarkdown(brainPath);
+    const missingPurpose = [];
+    const missingParent = [];
+    const missingUp = [];
+    for (const rel of markdown) {
+        const content = await readText(join(brainPath, rel));
+        if (!/^>\s+/m.test(content))
+            missingPurpose.push(rel);
+        if (!ROOT_FILES_WITHOUT_PARENT.has(rel) && !/^---[\s\S]*?^parent:/m.test(content))
+            missingParent.push(rel);
+        if (!ROOT_FILES_WITHOUT_UP.has(rel) && !content.includes('up:: [['))
+            missingUp.push(rel);
+    }
+    const findings = [];
+    if (missingPurpose.length)
+        findings.push({ message: `${missingPurpose.length} markdown file(s) have no purpose blockquote.`, details: missingPurpose.slice(0, DETAIL_LIMIT) });
+    if (missingParent.length)
+        findings.push({ message: `${missingParent.length} markdown file(s) have no parent frontmatter.`, details: missingParent.slice(0, DETAIL_LIMIT) });
+    if (missingUp.length)
+        findings.push({ message: `${missingUp.length} markdown file(s) have no up:: graph link.`, details: missingUp.slice(0, DETAIL_LIMIT) });
+    return result('review.markdown-hygiene', 'Markdown routing hygiene', findings, `${markdown.length} markdown file(s) scanned.`, false, brainPath);
+}
+export async function reviewBrain(options = {}) {
+    const brainPath = options.brainPath;
+    if (!brainPath) {
+        return {
+            ok: false,
+            checks: [
+                result('review.configured', 'Second-brain path configured', [{ message: 'No second-brain path is configured.' }], 'Run `sanook brain init [path]` first.', true),
+            ],
+        };
+    }
+    if (!(await pathExistsAsDir(brainPath))) {
+        return {
+            ok: false,
+            brainPath,
+            checks: [
+                result('review.path', 'Second-brain path exists', [{ message: 'Configured second-brain path does not exist or is not a directory.', path: brainPath }], 'Configured brainPath is not usable.', true, brainPath),
+            ],
+        };
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const checks = [
+        await checkMemoryInbox(brainPath, nowMs, options.memoryInboxMaxAgeDays ?? DEFAULT_MEMORY_INBOX_MAX_AGE_DAYS),
+        await checkContextPacks(brainPath, nowMs, options.contextPackMaxAgeDays ?? DEFAULT_CONTEXT_PACK_MAX_AGE_DAYS),
+        await checkSessionIndexCoverage(brainPath, options.indexPath ?? INDEX_PATH),
+        await checkEvalFreshness(brainPath, options.evalFreshnessToleranceMs ?? DEFAULT_EVAL_FRESHNESS_TOLERANCE_MS),
+        await checkFinalGates(brainPath),
+    ];
+    if (options.scanMarkdownHygiene !== false)
+        checks.push(await checkMarkdownHygiene(brainPath));
+    return { ok: !checks.some((check) => check.status === 'fail'), brainPath, checks };
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(4);
+}
+export function formatBrainReviewReport(report) {
+    const lines = ['Sanook brain review', `vault: ${report.brainPath ?? '(not configured)'}`];
+    const warnCount = report.checks.filter((check) => check.status === 'warn').length;
+    const failCount = report.checks.filter((check) => check.status === 'fail').length;
+    lines.push(`summary: ${report.checks.length} check(s), ${warnCount} warning(s), ${failCount} failure(s)`);
+    for (const check of report.checks) {
+        lines.push(`[${statusLabel(check.status)}] ${check.id} — ${check.message}`);
+        if (check.path)
+            lines.push(`       ${check.path}`);
+        for (const finding of check.findings ?? []) {
+            lines.push(`       - ${finding.message}`);
+            if (finding.path && finding.path !== check.path)
+                lines.push(`         ${finding.path}`);
+            for (const detail of finding.details ?? [])
+                lines.push(`         · ${detail}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/brain.js

@@ -67,7 +67,17 @@ export const FOLDERS = [
     { dir: 'Shared/Scripts', role: 'automation maintenance (lint/graph audit/metrics)', put: 'สคริปต์ maintenance ที่รันจริง', avoid: 'one-off ที่ retired (→Scripts-Archive)' },
     { dir: 'Shared/Scripts-Archive', role: 'สคริปต์ one-off ที่ retired', put: 'script เก่าเก็บเป็นประวัติ', avoid: 'script ที่ยังใช้ (→Scripts)' },
     { dir: 'Shared/mcp-servers', role: 'vendored local MCP server bundle (code/README)', put: 'โค้ด/README ของ MCP server (config อยู่ Tech-Standards)', avoid: 'config การต่อ (→Tech-Standards/mcp.json)' },
-    { dir: 'Shared/Context-Packs', role: 'full-context bundle ต่อ domain/task-type', put: 'pack รวม context พร้อมโหลด', avoid: 'โน้ตเดี่ยว (→ปลายทางปกติ)' },
+    {
+        dir: 'Shared/Context-Packs',
+        role: 'full-context bundle ต่อ domain/task-type',
+        put: 'pack รวม context พร้อมโหลด',
+        avoid: 'โน้ตเดี่ยว (→ปลายทางปกติ)',
+        links: [
+            '- [[Shared/Context-Packs/second-brain-maintenance]] — แก้ vault structure, routing, memory policy, indexes, runbooks, agent adapters',
+            '- [[Shared/Context-Packs/coding-release]] — แก้ code/tests/build/release/CLI scripts',
+            '- [[Shared/Context-Packs/research-to-framework]] — research/experiment → framework update',
+        ],
+    },
     { dir: 'Shared/Context7-Docs', role: 'cached external lib doc (regenerable — gitignore)', put: 'cache ของ context7/lib doc', avoid: 'durable knowledge (→Learning/Research)' },
     { dir: 'Shared/AI-Threads', role: 'saved AI reasoning/conversation trail (ไม่ใช่ source of truth)', put: 'thread ที่เก็บไว้ review/resume/promote', avoid: 'durable decision (promote → Decision-Memory)' },
     { dir: 'Shared/Prompting', role: 'prompt-engineering pattern (style/structure)', put: 'pattern การเขียน prompt ที่ reuse', avoid: 'prompt asset ต่อ task (→Prompts)' },
@@ -132,6 +142,7 @@ ${f.avoid ?? '_(—)_'}
 
 _(ยังว่าง — โน้ตในโฟลเดอร์นี้จะถูกลิงก์ที่นี่)_
 
+${f.links?.length ? `## Seed Notes\n\n${f.links.join('\n')}\n\n` : ''}
 up:: [[${parent}]]
 `;
 }

package/dist/brand.js

@@ -36,7 +36,7 @@ export function appTempPath(name) {
     return join(tmpdir(), name);
 }
 export function envFlag(name) {
-    const v = process.env[name];
+    const v = process.env[name]?.trim();
     return v === '1' || v?.toLowerCase() === 'true' || v?.toLowerCase() === 'yes';
 }
 export function persistenceEnabled() {

package/dist/cli-args.js

@@ -0,0 +1,152 @@
+import { inlineValue, takeValue } from './cli-option-values.js';
+const DECIMAL_BUDGET_RE = /^\+?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+const POSITIVE_INTEGER_RE = /^\d+$/;
+export function parseBudgetUsd(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    if (!DECIMAL_BUDGET_RE.test(normalized))
+        return undefined;
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+export function parseThinkingConfigValue(value) {
+    const normalized = value.trim();
+    const flag = normalized.toLowerCase();
+    if (flag === 'on' || flag === 'true')
+        return true;
+    if (flag === 'off' || flag === 'false')
+        return false;
+    if (!POSITIVE_INTEGER_RE.test(normalized))
+        return undefined;
+    const parsed = Number(normalized);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function optionArgs(argv) {
+    const end = argv.indexOf('--');
+    return end === -1 ? argv : argv.slice(0, end);
+}
+export function hasResumeRequest(argv) {
+    return optionArgs(argv).some((arg) => arg === '--resume' || arg === '-r' || arg.startsWith('--resume='));
+}
+export function hasContinueRequest(argv) {
+    return optionArgs(argv).some((arg) => arg === '--continue' || arg === '-c' || arg === '--continue-any');
+}
+export function hasContinueAnyRequest(argv) {
+    return optionArgs(argv).includes('--continue-any');
+}
+export function hasServeCommandRequest(argv) {
+    if (argv[0] !== 'serve')
+        return false;
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--')
+            return false;
+        if (arg === '--port' || arg === '--model' || arg === '-m') {
+            i = takeValue(argv, i).nextIndex;
+            continue;
+        }
+        if (arg.startsWith('--port=') || arg.startsWith('--model='))
+            continue;
+        return false;
+    }
+    return true;
+}
+function parsePortValue(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw))
+        return undefined;
+    const port = Number(raw);
+    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : undefined;
+}
+function portErrorValue(raw) {
+    return raw === undefined || raw === '' ? 'ต้องระบุค่า' : raw;
+}
+export function parseServeArgs(argv) {
+    let port = 8787;
+    let model;
+    let portError;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--port' || a.startsWith('--port=')) {
+            const next = a === '--port' ? takeValue(argv, i) : undefined;
+            const raw = next ? next.value : inlineValue('--port', a);
+            if (next)
+                i = next.nextIndex;
+            const parsed = parsePortValue(raw);
+            if (parsed === undefined)
+                portError = portErrorValue(raw);
+            else
+                port = parsed;
+        }
+        else if (a === '--model' || a === '-m' || a.startsWith('--model=')) {
+            if (a.startsWith('--model=')) {
+                model = inlineValue('--model', a);
+            }
+            else {
+                const next = takeValue(argv, i);
+                model = next.value;
+                i = next.nextIndex;
+            }
+        }
+    }
+    return { port, model, portError };
+}
+export function parseArgs(argv) {
+    let model;
+    let budget;
+    let json = false;
+    let quiet = false;
+    let planMode = false;
+    let yes = false;
+    let resume;
+    const rest = [];
+    let i = 0;
+    const takeArgValue = (index) => {
+        const next = takeValue(argv, index);
+        i = next.nextIndex;
+        return next.value;
+    };
+    for (; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--') {
+            rest.push(...argv.slice(i + 1));
+            break;
+        }
+        if (a.startsWith('--model='))
+            model = inlineValue('--model', a);
+        else if (a === '--model' || a === '-m')
+            model = takeArgValue(i);
+        else if (a.startsWith('--budget=')) {
+            budget = parseBudgetUsd(inlineValue('--budget', a));
+        }
+        else if (a === '--budget' || a === '-b') {
+            budget = parseBudgetUsd(takeArgValue(i));
+        }
+        else if (a === '--json')
+            json = true;
+        else if (a === '-q' || a === '--quiet')
+            quiet = true;
+        else if (a.startsWith('--output-format=') || a === '--output-format') {
+            const v = a.startsWith('--output-format=') ? inlineValue('--output-format', a) : takeArgValue(i);
+            if (v === 'json')
+                json = true;
+            else if (v === 'final' || v === 'quiet')
+                quiet = true;
+            /* 'text' = default */
+        }
+        else if (a === '--plan')
+            planMode = true;
+        else if (a === '--yes' || a === '-y' || a === '--yolo' || a === '--dangerously-skip-permissions')
+            yes = true;
+        else if (a.startsWith('--resume='))
+            resume = inlineValue('--resume', a);
+        else if (a === '--resume' || a === '-r')
+            resume = takeArgValue(i);
+        else if (a === '-p' || a === '--print' || a === '-c' || a === '--continue' || a === '--continue-any') {
+            /* -p headless flag · -c/--continue/--continue-any resume (handled in main) */
+        }
+        else
+            rest.push(a);
+    }
+    return { model, budget, json, quiet, prompt: rest.join(' ').trim(), planMode, yes, resume };
+}

package/dist/cli-option-values.js

@@ -0,0 +1,16 @@
+export function isFlagLike(value) {
+    return value.startsWith('--') || /^-[A-Za-z]/.test(value);
+}
+export function inlineValue(flag, value) {
+    const prefix = `${flag}=`;
+    if (!value.startsWith(prefix))
+        return undefined;
+    const parsed = value.slice(prefix.length);
+    return parsed === '' ? undefined : parsed;
+}
+export function takeValue(argv, index) {
+    const value = argv[index + 1];
+    if (value === undefined || isFlagLike(value))
+        return { nextIndex: index };
+    return { value, nextIndex: index + 1 };
+}