@north-light/crouter 0.3.154

package/dist/commands/sys/__tests__/sync-import.test.js

@@ -0,0 +1,314 @@
+// Regression: `crtr sys sync skills` is the one-shot migration path from
+// legacy Agent Skill bundles into crouter memory docs. The hard cut removes
+// SKILL.md as an active guidance surface, but must keep the converter.
+// `crtr sys sync project-guidance` is the separate migration path for
+// CLAUDE.md/AGENTS.md/.claude/rules — the hard cut that removes crtr's own
+// bolted-on project-context loader (bearings.ts, nested-context.ts) in favor
+// of the document substrate.
+//
+// Run: node --import tsx/esm --test src/commands/sys/__tests__/sync-import.test.ts
+import { afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode } from '../../../core/canvas/canvas.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { resolveMemoryDoc } from '../../../core/memory-resolver.js';
+import { parseFrontmatterGeneric } from '../../../core/frontmatter.js';
+import { gitSync } from '../../../core/git.js';
+import { renderKnowledgeBlock } from '../../../core/substrate/render-node.js';
+import { clearSessionCache } from '../../../core/substrate/session-cache.js';
+import { sysSyncSkillsLeaf } from '../sync-skills.js';
+import { sysSyncProjectGuidanceLeaf } from '../sync-project-guidance.js';
+function git(args, cwd) {
+    const res = gitSync(args, cwd);
+    if (res.status !== 0)
+        throw new Error(`git ${args.join(' ')} failed in ${cwd}: ${res.stderr || res.stdout}`);
+}
+function node(id, cwd) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
+let home;
+let prevHome;
+beforeEach(() => {
+    closeDb();
+    clearSessionCache();
+    prevHome = process.env.HOME;
+    home = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-'));
+    process.env.HOME = home;
+});
+afterEach(() => {
+    closeDb();
+    clearSessionCache();
+    if (prevHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = prevHome;
+    rmSync(home, { recursive: true, force: true });
+});
+test('imports a SKILL.md bundle as a plain crouter memory doc', async () => {
+    const sourceRoot = join(home, '.claude', 'skills');
+    const bundle = join(sourceRoot, 'demo-skill');
+    mkdirSync(bundle, { recursive: true });
+    writeFileSync(join(bundle, 'SKILL.md'), '---\nname: Demo Skill\ndescription: Handles demos. Use when demo work appears.\n---\n\n# Demo\n\nDo the demo.\n', 'utf8');
+    const result = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user' });
+    assert.equal(result?.imported, 1);
+    const target = join(home, '.crouter', 'memory', 'demo-skill.md');
+    assert.equal(existsSync(target), true);
+    const parsed = parseFrontmatterGeneric(readFileSync(target, 'utf8'));
+    assert.equal(parsed.data?.kind, 'knowledge');
+    assert.equal(parsed.data?.['system-prompt-visibility'], 'preview');
+    assert.equal(parsed.data?.['file-read-visibility'], 'none');
+    assert.equal(parsed.data?.['when-and-why-to-read'], 'When demo work appears, this knowledge should be read because handles demos.');
+    assert.match(parsed.body, /Do the demo\./);
+});
+test('skips SKILL.md files vendored under node_modules while still importing a top-level authored SKILL.md', async () => {
+    const sourceRoot = join(home, 'repo');
+    const vendored = join(sourceRoot, 'node_modules', '@tanstack', 'some-pkg');
+    mkdirSync(vendored, { recursive: true });
+    writeFileSync(join(vendored, 'SKILL.md'), '---\nname: Vendored Skill\ndescription: Should never be imported.\n---\n\n# Vendored\n', 'utf8');
+    const authored = join(sourceRoot, 'my-skill');
+    mkdirSync(authored, { recursive: true });
+    writeFileSync(join(authored, 'SKILL.md'), '---\nname: My Skill\ndescription: Handles the real thing. Use when real work appears.\n---\n\n# Real\n\nDo the real thing.\n', 'utf8');
+    const result = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user' });
+    assert.equal(result?.imported, 1);
+    assert.equal(existsSync(join(home, '.crouter', 'memory', 'vendored-skill.md')), false);
+    assert.equal(existsSync(join(home, '.crouter', 'memory', 'my-skill.md')), true);
+    const rows = (result?.results).map((r) => r.source);
+    assert.ok(!rows.some((s) => s.includes('node_modules')));
+});
+test('skips generated crtr boot skills instead of importing them', async () => {
+    const bundle = join(home, '.pi', 'agent', 'skills', 'crtr-skills');
+    mkdirSync(bundle, { recursive: true });
+    writeFileSync(join(bundle, 'SKILL.md'), '---\nname: crtr-skills\n---\n\n<!-- crtr-boot-skill v2 -->\n', 'utf8');
+    const result = await sysSyncSkillsLeaf.run({ source: bundle, scope: 'user' });
+    assert.equal(result?.imported, 0);
+    assert.equal(result?.skipped, 1);
+    assert.equal(existsSync(join(home, '.crouter', 'memory', 'crtr-skills.md')), false);
+});
+test('permanently ignores selected SKILL.md bundles', async () => {
+    const sourceRoot = join(home, '.claude', 'skills');
+    const bundle = join(sourceRoot, 'ignored-skill');
+    mkdirSync(bundle, { recursive: true });
+    writeFileSync(join(bundle, 'SKILL.md'), '---\nname: Ignored Skill\ndescription: Ignore me. Use when testing ignores.\n---\n\n# Ignore\n', 'utf8');
+    const ignored = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user', ignore: true });
+    assert.equal(ignored?.ignored, 1);
+    assert.equal(existsSync(join(home, '.crouter', 'skill-import-ignore.json')), true);
+    const dry = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user', dryRun: true });
+    assert.equal(dry?.wouldImport, 0);
+    assert.equal((dry?.results).length, 0);
+    const shown = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user', dryRun: true, includeIgnored: true });
+    assert.equal(shown?.ignored, 1);
+    assert.equal((shown?.results)[0].status, 'ignored');
+    const wouldIgnore = await sysSyncSkillsLeaf.run({ source: sourceRoot, scope: 'user', dryRun: true, ignore: true });
+    assert.equal(wouldIgnore?.wouldIgnore, 1);
+    assert.equal((wouldIgnore?.results)[0].status, 'would-ignore');
+    const rendered = sysSyncSkillsLeaf.render?.(wouldIgnore);
+    assert.notEqual(rendered, undefined);
+    assert.match(rendered, /would ignore/);
+});
+test('migrates CLAUDE.md and a .claude/rules file into that dir\'s own .crouter/memory/, copy-not-move, skip-existing, --overwrite replaces', async () => {
+    const source = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-projectdocs-'));
+    writeFileSync(join(source, 'CLAUDE.md'), '# Demo Project\n\nBuild then commit.\n', 'utf8');
+    mkdirSync(join(source, '.claude', 'rules'), { recursive: true });
+    writeFileSync(join(source, '.claude', 'rules', 'foo.md'), '---\nname: foo\ndescription: Applies when touching src files.\npaths:\n  - "src/**/*.ts"\n---\n\nDo the foo thing.\n', 'utf8');
+    const dry = await sysSyncProjectGuidanceLeaf.run({ source, dryRun: true });
+    const dryRows = dry?.results;
+    assert.equal(dryRows.length, 2, 'both the AGENTS.md and the rule dry-run as candidates');
+    assert.ok(dryRows.every((r) => r.status === 'would-import'));
+    assert.equal(existsSync(join(source, '.crouter', 'memory', 'AGENTS.md')), false, 'dry-run writes nothing');
+    await sysSyncProjectGuidanceLeaf.run({ source });
+    const agentsTarget = join(source, '.crouter', 'memory', 'AGENTS.md');
+    const ruleTarget = join(source, '.crouter', 'memory', 'foo.md');
+    assert.equal(existsSync(agentsTarget), true);
+    assert.equal(existsSync(ruleTarget), true);
+    const agentsDoc = parseFrontmatterGeneric(readFileSync(agentsTarget, 'utf8'));
+    assert.equal(agentsDoc.data?.kind, 'knowledge');
+    assert.equal(agentsDoc.data?.name, 'demo-project');
+    assert.equal(agentsDoc.data?.['system-prompt-visibility'], 'content');
+    assert.equal(agentsDoc.data?.['file-read-visibility'], 'content');
+    assert.match(agentsDoc.body, /Build then commit\./);
+    const prevCwd = process.cwd();
+    process.chdir(source);
+    try {
+        assert.equal(resolveMemoryDoc('demo-project').path, realpathSync(agentsTarget));
+        assert.equal(resolveMemoryDoc('demo-project').name, 'demo-project');
+    }
+    finally {
+        process.chdir(prevCwd);
+    }
+    const ruleDoc = parseFrontmatterGeneric(readFileSync(ruleTarget, 'utf8'));
+    assert.equal(ruleDoc.data?.kind, 'knowledge');
+    assert.equal(ruleDoc.data?.['system-prompt-visibility'], 'none');
+    assert.equal(ruleDoc.data?.['file-read-visibility'], 'content');
+    assert.deepEqual(ruleDoc.data?.['applies-to'], ['src/**/*.ts']);
+    assert.match(ruleDoc.body, /Do the foo thing\./);
+    // Originals untouched — copy, not move.
+    assert.equal(existsSync(join(source, 'CLAUDE.md')), true);
+    assert.equal(existsSync(join(source, '.claude', 'rules', 'foo.md')), true);
+    // Re-run skips existing targets.
+    const rerun = await sysSyncProjectGuidanceLeaf.run({ source });
+    const rerunRows = rerun?.results;
+    assert.ok(rerunRows.every((r) => r.status === 'skipped'));
+    // --overwrite replaces.
+    writeFileSync(join(source, 'CLAUDE.md'), '# Demo Project v2\n\nBuild, THEN commit.\n', 'utf8');
+    const overwritten = await sysSyncProjectGuidanceLeaf.run({ source, overwrite: true });
+    const overwriteRows = overwritten?.results;
+    assert.ok(overwriteRows.some((r) => r.status === 'imported'));
+    const agentsDoc2 = parseFrontmatterGeneric(readFileSync(agentsTarget, 'utf8'));
+    assert.match(agentsDoc2.body, /Build, THEN commit\./);
+    rmSync(source, { recursive: true, force: true });
+});
+test('routes the walk-root AGENTS.md doc by the real git repo name, not a worktree\'s own basename', async () => {
+    // Regression: running the migration from a linked git worktree (e.g. a
+    // canvas node's checkout, whose directory is named after a node id) must
+    // not bake that node id into the migrated doc's routing text — it should
+    // resolve through to the actual repo name shared by every worktree.
+    const base = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-worktree-'));
+    const mainRepo = join(base, 'demo-repo');
+    mkdirSync(mainRepo, { recursive: true });
+    git(['init', '-b', 'main'], mainRepo);
+    git(['config', 'user.email', 'test@example.com'], mainRepo);
+    git(['config', 'user.name', 'Test'], mainRepo);
+    writeFileSync(join(mainRepo, 'README.md'), 'hello\n', 'utf8');
+    git(['add', '.'], mainRepo);
+    git(['commit', '-m', 'init'], mainRepo);
+    // A linked worktree whose basename looks nothing like the repo name.
+    const linkedWorktree = join(base, 'mr9xyz12-abcd3456');
+    git(['worktree', 'add', linkedWorktree, '-b', 'feature'], mainRepo);
+    writeFileSync(join(linkedWorktree, 'CLAUDE.md'), '# Fallback Title\n\nRepo guidance.\n', 'utf8');
+    const result = await sysSyncProjectGuidanceLeaf.run({ source: linkedWorktree });
+    assert.equal(result?.imported, 1);
+    const target = join(linkedWorktree, '.crouter', 'memory', 'AGENTS.md');
+    const doc = parseFrontmatterGeneric(readFileSync(target, 'utf8'));
+    assert.equal(doc.data?.['when-and-why-to-read'], 'When working in demo-repo, this knowledge should be read because it is the project\'s operating guide.');
+    git(['worktree', 'remove', '--force', linkedWorktree], mainRepo);
+    rmSync(base, { recursive: true, force: true });
+});
+test('sibling purview roots keep distinct AGENTS names so boot render does not dedupe them away', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-purview-'));
+    const rootA = join(base, 'alpha-root');
+    const rootB = join(base, 'beta-root');
+    mkdirSync(rootA, { recursive: true });
+    mkdirSync(rootB, { recursive: true });
+    writeFileSync(join(rootA, 'CLAUDE.md'), '# Alpha Root\n\nAlpha body.\n', 'utf8');
+    writeFileSync(join(rootB, 'CLAUDE.md'), '# Beta Root\n\nBeta body.\n', 'utf8');
+    await sysSyncProjectGuidanceLeaf.run({ source: rootA });
+    await sysSyncProjectGuidanceLeaf.run({ source: rootB });
+    const profileId = 'purview-b7a4d1f0';
+    const profileDir = join(home, '.crouter', 'profiles', profileId);
+    mkdirSync(profileDir, { recursive: true });
+    writeFileSync(join(profileDir, 'profile.json'), JSON.stringify({ name: 'purview-pair', projects: [rootA, rootB], created_at: new Date().toISOString() }, null, 2) + '\n', 'utf8');
+    const runDir = join(base, 'run');
+    mkdirSync(runDir, { recursive: true });
+    const prevCwd = process.cwd();
+    const prevProfileId = process.env.CRTR_PROFILE_ID;
+    try {
+        process.env.CRTR_PROFILE_ID = profileId;
+        process.chdir(runDir);
+        clearSessionCache();
+        const alphaDoc = resolveMemoryDoc('alpha-root');
+        assert.equal(alphaDoc.path, join(rootA, '.crouter', 'memory', 'AGENTS.md'));
+        assert.equal(alphaDoc.name, 'alpha-root');
+        const betaDoc = resolveMemoryDoc('beta-root');
+        assert.equal(betaDoc.path, join(rootB, '.crouter', 'memory', 'AGENTS.md'));
+        assert.equal(betaDoc.name, 'beta-root');
+        createNode(node('bootcheck', runDir));
+        const block = renderKnowledgeBlock('bootcheck');
+        assert.match(block, /Alpha body\./, 'first purview root survives the boot render');
+        assert.match(block, /Beta body\./, 'second purview root survives the boot render');
+    }
+    finally {
+        process.chdir(prevCwd);
+        if (prevProfileId === undefined)
+            delete process.env.CRTR_PROFILE_ID;
+        else
+            process.env.CRTR_PROFILE_ID = prevProfileId;
+    }
+    rmSync(base, { recursive: true, force: true });
+});
+test('a nested project-subdir AGENTS/CLAUDE doc migrates to its OWN <nested>/.crouter/memory/AGENTS.md with a deterministic, non-colliding explicit name', async () => {
+    const source = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-nested-'));
+    writeFileSync(join(source, 'CLAUDE.md'), '# Nested Demo\n\nRoot guidance.\n', 'utf8');
+    const nestedDir = join(source, 'packages', 'widgets');
+    mkdirSync(nestedDir, { recursive: true });
+    writeFileSync(join(nestedDir, 'AGENTS.md'), '# Widgets Package\n\nNested guidance.\n', 'utf8');
+    const result = await sysSyncProjectGuidanceLeaf.run({ source });
+    const projectRows = result?.results;
+    assert.equal(projectRows.length, 2, 'both the root and nested docs are candidates');
+    assert.ok(projectRows.every((r) => r.status === 'imported'));
+    const rootTarget = join(source, '.crouter', 'memory', 'AGENTS.md');
+    const nestedTarget = join(nestedDir, '.crouter', 'memory', 'AGENTS.md');
+    assert.equal(existsSync(rootTarget), true, 'root doc writes to the root\'s OWN .crouter/memory/AGENTS.md');
+    assert.equal(existsSync(nestedTarget), true, 'nested doc writes to the NESTED dir\'s OWN .crouter/memory/AGENTS.md, not the root store');
+    const rootDoc = parseFrontmatterGeneric(readFileSync(rootTarget, 'utf8'));
+    const nestedDoc = parseFrontmatterGeneric(readFileSync(nestedTarget, 'utf8'));
+    assert.equal(rootDoc.data?.name, 'nested-demo');
+    assert.equal(nestedDoc.data?.name, 'nested-demo/packages/widgets');
+    assert.notEqual(rootDoc.data?.name, nestedDoc.data?.name, 'root and nested identities never collide');
+    assert.match(rootDoc.body, /Root guidance\./);
+    assert.match(nestedDoc.body, /Nested guidance\./);
+    const prevCwd = process.cwd();
+    try {
+        process.chdir(nestedDir);
+        clearSessionCache();
+        const resolved = resolveMemoryDoc('nested-demo/packages/widgets');
+        assert.equal(resolved.path, realpathSync(nestedTarget), 'resolveMemoryDoc finds a migrated nested doc by its explicit slashed identity');
+        assert.equal(resolved.name, 'nested-demo/packages/widgets');
+        assert.match(resolved.body, /Nested guidance\./);
+    }
+    finally {
+        process.chdir(prevCwd);
+    }
+    rmSync(source, { recursive: true, force: true });
+});
+test('a nested project-subdir doc migrated when --source POINTS AT THE NESTED DIR ITSELF still gets a suffix-qualified, non-colliding name', async () => {
+    // A nested doc's name suffix is computed against the git worktree top-level,
+    // not the supplied walk root, so `--source <nested-dir>` still yields a
+    // qualified, non-colliding name even when the walk starts at the nested dir.
+    const base = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-nested-source-'));
+    const repoRoot = join(base, 'demo-repo');
+    mkdirSync(repoRoot, { recursive: true });
+    git(['init', '-b', 'main'], repoRoot);
+    git(['config', 'user.email', 'test@example.com'], repoRoot);
+    git(['config', 'user.name', 'Test'], repoRoot);
+    writeFileSync(join(repoRoot, 'CLAUDE.md'), '# Demo Repo\n\nRoot guidance.\n', 'utf8');
+    const nestedDir = join(repoRoot, 'packages', 'widgets');
+    mkdirSync(nestedDir, { recursive: true });
+    writeFileSync(join(nestedDir, 'AGENTS.md'), '# Widgets Package\n\nNested guidance.\n', 'utf8');
+    git(['add', '.'], repoRoot);
+    git(['commit', '-m', 'init'], repoRoot);
+    // --source pinned directly at the nested dir, with the root project doc left
+    // unmigrated, so the nested doc's name must stay qualified on its own.
+    const nestedResult = await sysSyncProjectGuidanceLeaf.run({ source: nestedDir });
+    assert.equal(nestedResult?.imported, 1);
+    const nestedTarget = join(nestedDir, '.crouter', 'memory', 'AGENTS.md');
+    assert.equal(existsSync(nestedTarget), true);
+    const nestedDoc = parseFrontmatterGeneric(readFileSync(nestedTarget, 'utf8'));
+    assert.equal(nestedDoc.data?.name, 'demo-repo/packages/widgets', 'nested doc name is suffix-qualified even though --source pinned the nested dir directly');
+    assert.notEqual(nestedDoc.data?.name, 'demo-repo', 'nested identity never collapses to the bare root project label it would collide with');
+    assert.match(nestedDoc.body, /Nested guidance\./);
+    const projectRows = nestedResult?.results;
+    assert.ok(projectRows.some((r) => r.status === 'imported' && r.target === nestedTarget));
+    rmSync(base, { recursive: true, force: true });
+});
+test('falls back to the doc H1 title when the walk root is not inside a git repo', async () => {
+    const source = mkdtempSync(join(tmpdir(), 'crtr-sys-sync-nogit-'));
+    writeFileSync(join(source, 'CLAUDE.md'), '# Standalone Docs Project\n\nDo the thing.\n', 'utf8');
+    const result = await sysSyncProjectGuidanceLeaf.run({ source });
+    assert.equal(result?.imported, 1);
+    const target = join(source, '.crouter', 'memory', 'AGENTS.md');
+    const doc = parseFrontmatterGeneric(readFileSync(target, 'utf8'));
+    assert.equal(doc.data?.['when-and-why-to-read'], 'When working in standalone-docs-project, this knowledge should be read because it is the project\'s operating guide.');
+    rmSync(source, { recursive: true, force: true });
+});

package/dist/commands/sys/config.d.ts

@@ -0,0 +1 @@
+export declare const configBranch: import("../../core/command.js").BranchDef;

package/dist/commands/sys/config.js

@@ -0,0 +1,292 @@
+import { defineBranch, defineLeaf } from '../../core/command.js';
+import { readConfig, updateConfig, persistModelLadders, configPath as coreConfigPath } from '../../core/config.js';
+import { usage, notFound } from '../../core/errors.js';
+import { scopeRoot, requireScopeRoot, listScopes } from '../../core/scope.js';
+import { resolveScope } from './shared.js';
+import { CONDENSED_HISTORY_MODES } from '../../types.js';
+// ---------------------------------------------------------------------------
+// Config helpers (ported from commands/config.ts)
+// ---------------------------------------------------------------------------
+const TOP_LEVEL_KEYS = new Set([
+    'auto_update',
+    'marketplaces',
+    'plugins',
+    'max_panes_per_window',
+    'brokerThresholds',
+    'completion_bell',
+    'live_cycles',
+    'condensed_history',
+    'modelLadders',
+]);
+const MODEL_PROVIDERS = new Set(['anthropic', 'openai']);
+const MODEL_STRENGTHS = new Set(['ultra', 'strong', 'medium', 'light']);
+function isModelProvider(value) {
+    return MODEL_PROVIDERS.has(value);
+}
+function isModelStrength(value) {
+    return MODEL_STRENGTHS.has(value);
+}
+function getNestedValue(obj, key) {
+    const parts = key.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function parseConfigValue(raw) {
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (/^-?\d+$/.test(raw))
+        return parseInt(raw, 10);
+    return raw;
+}
+function assertUserScopeBrokerThresholds(key, scope) {
+    if (key.split('.', 1)[0] === 'brokerThresholds' && scope !== 'user') {
+        throw usage('brokerThresholds are available only in user scope');
+    }
+}
+/** Validate a `modelLadders.*` key/value into an explicit sparse patch, or
+ *  return null when the key is not a ladder key. Ladder sets do NOT go through
+ *  `setNestedValue`/`updateConfig`: that path persists only what differs from
+ *  the compiled defaults, so choosing today's default value would record
+ *  nothing (see `persistModelLadders`). */
+function modelLadderPatch(key, rawValue) {
+    const parts = key.split('.');
+    if (parts[0] !== 'modelLadders')
+        return null;
+    if (parts.length === 2 && parts[1] === 'defaultProvider') {
+        if (!isModelProvider(rawValue)) {
+            throw usage(`modelLadders.defaultProvider must be anthropic or openai`);
+        }
+        return { defaultProvider: rawValue };
+    }
+    if (parts.length === 3) {
+        const provider = parts[1];
+        const strength = parts[2];
+        if (!isModelProvider(provider)) {
+            throw usage(`modelLadders provider must be anthropic or openai`);
+        }
+        if (!isModelStrength(strength)) {
+            throw usage(`modelLadders strength must be ultra, strong, medium, or light`);
+        }
+        if (rawValue.trim() === '') {
+            throw usage(`modelLadders.${provider}.${strength} cannot be empty`);
+        }
+        return { [provider]: { [strength]: rawValue } };
+    }
+    throw usage(`unsupported key path for set: ${key}`);
+}
+function setNestedValue(cfg, key, rawValue, value) {
+    const parts = key.split('.');
+    const topKey = parts[0];
+    if (topKey === 'keybindings') {
+        throw usage('keybindings are edited only through `crtr sys setup`');
+    }
+    if (topKey === 'modelLadders') {
+        throw usage('modelLadders keys are written through persistModelLadders, not this path');
+    }
+    if (!TOP_LEVEL_KEYS.has(topKey)) {
+        throw usage(`unknown config key: ${topKey} (expected: ${[...TOP_LEVEL_KEYS].join('|')})`);
+    }
+    if (key === 'auto_update.content') {
+        if (value !== 'notify' && value !== 'apply' && value !== false) {
+            throw usage(`auto_update.content must be 'notify', 'apply', or false`);
+        }
+        cfg.auto_update.content = value;
+        return;
+    }
+    if (key === 'auto_update.crtr') {
+        const coerced = value === true ? 'notify' : value;
+        if (coerced !== 'notify' && coerced !== 'apply' && coerced !== false) {
+            throw usage(`auto_update.crtr must be 'notify', 'apply', or false`);
+        }
+        cfg.auto_update.crtr = coerced;
+        return;
+    }
+    if (key === 'max_panes_per_window') {
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+            throw usage(`max_panes_per_window must be an integer >= 1`);
+        }
+        cfg.max_panes_per_window = Math.floor(value);
+        return;
+    }
+    if (topKey === 'brokerThresholds') {
+        if (parts.length !== 2 || (parts[1] !== 'warning' && parts[1] !== 'automaticReviveCap')) {
+            throw usage(`brokerThresholds key must be warning or automaticReviveCap`);
+        }
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+            throw usage(`brokerThresholds.${parts[1]} must be an integer >= 1`);
+        }
+        const threshold = Math.floor(value);
+        if (parts[1] === 'warning' && threshold > cfg.brokerThresholds.automaticReviveCap) {
+            throw usage('brokerThresholds.warning must be <= brokerThresholds.automaticReviveCap');
+        }
+        if (parts[1] === 'automaticReviveCap' && threshold < cfg.brokerThresholds.warning) {
+            throw usage('brokerThresholds.automaticReviveCap must be >= brokerThresholds.warning');
+        }
+        cfg.brokerThresholds[parts[1]] = threshold;
+        return;
+    }
+    if (key === 'completion_bell') {
+        if (typeof value !== 'boolean') {
+            throw usage(`completion_bell must be true or false`);
+        }
+        cfg.completion_bell = value;
+        return;
+    }
+    if (key === 'live_cycles') {
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+            throw usage(`live_cycles must be an integer >= 1`);
+        }
+        cfg.live_cycles = Math.floor(value);
+        return;
+    }
+    if (key === 'condensed_history') {
+        if (!CONDENSED_HISTORY_MODES.includes(rawValue)) {
+            throw usage(`condensed_history must be one of: ${CONDENSED_HISTORY_MODES.join('|')}`);
+        }
+        cfg.condensed_history = rawValue;
+        return;
+    }
+    if (parts.length === 1) {
+        cfg[topKey] = value;
+        return;
+    }
+    if (parts.length === 2 && topKey === 'auto_update') {
+        const subKey = parts[1];
+        cfg.auto_update[subKey] = value;
+        return;
+    }
+    throw usage(`unsupported key path for set: ${key}`);
+}
+// ---------------------------------------------------------------------------
+// Leaf definitions
+// ---------------------------------------------------------------------------
+const configGet = defineLeaf({
+    name: 'get',
+    description: 'read a config value by key',
+    whenToUse: 'you want to inspect one config value — including the whole user keybindings object — optionally from a specific scope. Use sys setup to edit keybindings and sys config set for supported scalar settings.',
+    help: {
+        name: 'sys config get',
+        summary: 'read a config value by dotted key',
+        params: [
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, brokerThresholds (user only; warning and automaticReviveCap), completion_bell, live_cycles, condensed_history, modelLadders, or the whole keybindings object. Keybindings are edited only through sys setup.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to read from. Default: user.' },
+        ],
+        output: [
+            { name: 'key', type: 'string', required: true, constraint: 'Echo of input key.' },
+            { name: 'value', type: 'unknown', required: true, constraint: 'The resolved value. Type depends on the key.' },
+            { name: 'scope', type: 'string', required: true, constraint: 'Scope the value was read from.' },
+        ],
+        outputKind: 'object',
+        effects: ['None. Read-only.'],
+    },
+    run: async (input) => {
+        const key = input['key'];
+        const scope = resolveScope(input['scope']);
+        assertUserScopeBrokerThresholds(key, scope);
+        if (key.startsWith('keybindings.') || (key === 'keybindings' && scope !== 'user')) {
+            throw notFound('keybindings are available only as the whole user-scope object');
+        }
+        const cfg = readConfig(scope);
+        const value = getNestedValue(cfg, key);
+        if (value === undefined) {
+            throw notFound(`config key not found: ${key}`);
+        }
+        return { key, value: value, scope };
+    },
+});
+const configSet = defineLeaf({
+    name: 'set',
+    description: 'write a config value by key',
+    whenToUse: 'you want to change a supported scalar crtr setting in user or project scope. Use sys setup instead for keybindings, and sys config get to inspect values.',
+    help: {
+        name: 'sys config set',
+        summary: 'write a config value by dotted key',
+        params: [
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, brokerThresholds.warning, brokerThresholds.automaticReviveCap (user scope; positive integers), completion_bell, live_cycles (integer >= 1 — trailing cycles the attach viewer renders at full fidelity; older cycles condense to prose), condensed_history (none|user|agent|both — which messages of a condensed cycle still render; none keeps only the cycle dividers), modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.' },
+            { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. Stored as-is if quoted; coerced to number or boolean when unambiguous.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user.' },
+        ],
+        output: [
+            { name: 'key', type: 'string', required: true, constraint: 'Echo of input key.' },
+            { name: 'value', type: 'unknown', required: true, constraint: 'Value as written.' },
+            { name: 'scope', type: 'string', required: true, constraint: 'Scope the value was written to.' },
+        ],
+        outputKind: 'object',
+        effects: ['Writes the updated value to config.json in the target scope.'],
+    },
+    run: async (input) => {
+        const key = input['key'];
+        const rawValue = input['value'];
+        const scope = resolveScope(input['scope']);
+        assertUserScopeBrokerThresholds(key, scope);
+        // Flags are stringly-typed; coerce to number or boolean when unambiguous
+        const parsed = parseConfigValue(rawValue);
+        // Ladder rungs record explicit intent (even when the value equals today's
+        // compiled default); everything else mutates + persists through the central
+        // raw-partial path, which never freezes a materialized `modelLadders`.
+        const ladder = modelLadderPatch(key, rawValue);
+        const cfg = ladder !== null
+            ? (persistModelLadders(requireScopeRoot(scope), ladder), readConfig(scope))
+            : updateConfig(scope, (c) => setNestedValue(c, key, rawValue, parsed));
+        // Read back the written value for echo
+        const written = getNestedValue(cfg, key);
+        return { key, value: written, scope };
+    },
+});
+const configPath = defineLeaf({
+    name: 'path',
+    description: 'print path(s) to config.json',
+    whenToUse: 'you need the absolute path to a user or project config.json for inspection or backup.',
+    help: {
+        name: 'sys config path',
+        summary: 'print absolute path(s) to config.json',
+        params: [
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Scope to show paths for. Default: all.' },
+        ],
+        output: [
+            { name: 'paths', type: 'object[]', required: true, constraint: 'Each: {scope, path}. Only includes scopes that have a config file.' },
+        ],
+        outputKind: 'object',
+        effects: ['None. Read-only.'],
+    },
+    run: async (input) => {
+        const scopeArg = input['scope'];
+        // Resolve 'all' or undefined → all writable scopes
+        let scopes;
+        if (scopeArg === undefined || scopeArg === 'all') {
+            scopes = listScopes(undefined);
+        }
+        else {
+            scopes = listScopes(scopeArg);
+        }
+        const paths = scopes
+            .map((s) => {
+            const root = scopeRoot(s);
+            if (!root)
+                return null;
+            const p = coreConfigPath(s);
+            if (!p)
+                return null;
+            return { scope: s, path: p };
+        })
+            .filter((x) => x !== null);
+        return { paths };
+    },
+});
+export const configBranch = defineBranch({
+    name: 'config',
+    description: 'read and write configuration',
+    whenToUse: 'inspecting crtr settings, changing supported scalar values, or locating config.json. Keybinding changes belong in sys setup.',
+    help: {
+        name: 'sys config',
+        summary: 'read and write crtr configuration, including model ladders',
+    },
+    children: [configGet, configSet, configPath],
+});

package/dist/commands/sys/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { BranchDef } from '../../core/command.js';
+export declare const daemonBranch: BranchDef;