super-backlog 0.3.4 → 0.5.0

package/dist/cli.js

@@ -5,6 +5,7 @@ import process from 'node:process';
 import { runDashboard } from './commands/dashboard.js';
 import { runDoctor } from './commands/doctor.js';
 import { runInit } from './commands/init.js';
+import { runModels } from './commands/models.js';
 import { runUninstall } from './commands/uninstall.js';
 import { runUpdate } from './commands/update.js';
 import { assertNode20, KIT_VERSION } from './lib/version.js';
@@ -17,12 +18,15 @@ Commands:
   uninstall   Remove kit-managed files (project data kept unless --with-backlog)
   update      Refresh kit-managed files and report upstream versions
   dashboard   Generate the single-file project dashboard (--serve for live mode)
+  models      Manage the model router (show, enable, disable, discover)
   doctor      Check the environment (node, PowerShell policy, backlog CLI)
 
 init options:
   --pm <auto|npm|pnpm|bun|skip>   Package manager to use (default: auto)
   --harness <opencode|claude>     Target harness; repeatable or comma-separated (default: both)
   --guard                         Install the integrity pre-commit hook (opt-in)
+  --models                        Install the model router config during init (opt-in)
+  --no-models                     Explicitly opt out of the model router
   --no-dashboard                  Skip generating the project dashboard
   --no-refresh-hook               Skip the post-commit dashboard freshness hook
   --dry-run                       Show what would be done without writing anything
@@ -67,6 +71,8 @@ async function main(argv) {
                     pm: { type: 'string' },
                     harness: { type: 'string', multiple: true },
                     guard: { type: 'boolean' },
+                    models: { type: 'boolean' },
+                    'no-models': { type: 'boolean' },
                     'no-dashboard': { type: 'boolean' },
                     'no-refresh-hook': { type: 'boolean' },
                     'dry-run': { type: 'boolean' },
@@ -111,6 +117,13 @@ async function main(argv) {
                 positionals: parsed.positionals,
             });
         }
+        case 'models': {
+            const parsed = parseArgs({ args: rest, allowPositionals: true, options: {} });
+            return await runModels(process.cwd(), {
+                values: parsed.values,
+                positionals: parsed.positionals,
+            });
+        }
         case 'doctor':
             return runDoctor(process.cwd());
         default:

package/dist/commands/init.js

@@ -23,6 +23,8 @@ function describeAction(action) {
             return 'write-claude-pointer CLAUDE.md';
         case 'copy-skills':
             return 'copy-skills (.opencode/skill + .claude/skills)';
+        case 'install-model-router':
+            return 'install-model-router .super-backlog/models.json';
         case 'install-guard-hook':
             return 'install-guard-hook .git/hooks/pre-commit';
         case 'install-refresh-hook':
@@ -74,6 +76,7 @@ export async function runInit(cwd, args) {
     const dashboard = args.values['no-dashboard'] !== true;
     const refreshHook = args.values['no-refresh-hook'] !== true; // default on, opt-out flag
     const dryRun = args.values['dry-run'] === true;
+    const models = args.values.models === true ? true : args.values['no-models'] === true ? false : undefined;
     const projectName = args.positionals[0] ?? basename(resolve(cwd));
     let opencodeConfig;
     const opencodePath = join(cwd, 'opencode.json');
@@ -95,7 +98,7 @@ export async function runInit(cwd, args) {
         opencodeConfig,
         pkgExists: existsSync(join(cwd, 'package.json')),
     };
-    const opts = { projectName, harnesses, pm, guard, dashboard, refreshHook, skipInstall: false };
+    const opts = { projectName, harnesses, pm, guard, dashboard, refreshHook, skipInstall: false, models };
     const plan = planInit(state, opts, KIT_VERSION);
     if (dryRun) {
         console.log(`dry-run for "${projectName}": ${plan.actions.length} action(s) planned, nothing written`);

package/dist/commands/models.js

@@ -0,0 +1,34 @@
+// src/commands/models.ts
+import { loadConfig } from '../models/config.js';
+import { discoverModels } from '../models/discovery.js';
+import { writeRouterConfig } from '../models/install.js';
+export async function runModels(cwd, args) {
+    const sub = args.positionals[0] ?? 'show';
+    switch (sub) {
+        case 'show': {
+            const cfg = loadConfig(cwd);
+            console.log(JSON.stringify(cfg, null, 2));
+            return 0;
+        }
+        case 'enable':
+            writeRouterConfig(cwd, true);
+            console.log('model router enabled');
+            return 0;
+        case 'disable':
+            writeRouterConfig(cwd, false);
+            console.log('model router disabled');
+            return 0;
+        case 'discover': {
+            const resolved = await discoverModels(cwd);
+            if (!resolved) {
+                console.error('discovery failed');
+                return 1;
+            }
+            console.log(JSON.stringify(resolved, null, 2));
+            return 0;
+        }
+        default:
+            console.error(`unknown models subcommand: ${sub}`);
+            return 1;
+    }
+}

package/dist/commands/uninstall.js

@@ -8,6 +8,7 @@ import { stripOwned } from '../lib/markers.js';
 import { PLUGIN_SPEC } from '../lib/opencode.js';
 import { isOwnedSkillFile } from '../lib/ownership.js';
 import { WANTED_SCRIPTS } from '../lib/pkgjson.js';
+import { uninstallModelRouter } from '../models/uninstall.js';
 const OWNED_SKILL_DIRS = [
     '.opencode/skill/spec-to-backlog',
     '.opencode/skill/backlog-status-report',
@@ -265,6 +266,7 @@ export function runUninstall(cwd, args) {
             label: 'backlog/ (project task data preserved - pass --with-backlog to delete)',
         });
     }
+    uninstallModelRouter(cwd, report);
     console.log('super-backlog uninstall');
     for (const line of report)
         console.log(`${line.verdict}: ${line.label}`);

package/dist/dashboard/server.js

@@ -5,6 +5,7 @@ import { readFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { isAbsolute, join } from 'node:path';
 import process from 'node:process';
+import { createModelApiHandler } from '../models/dashboard-api.js';
 export const DASHBOARD_PORT = 6428;
 export function recursiveWatchSupported(platform, nodeVersion) {
     // Node 24 on Windows triggers a libuv assertion in recursive fs.watch:
@@ -70,7 +71,12 @@ export async function startServeServer(cwd, opts = {}) {
     else {
         console.warn('warning: live reload is disabled because Node 24+ on Windows cannot reliably watch directories recursively (libuv fs-event bug); use Node 22 or Linux/macOS for --serve');
     }
+    const modelApi = createModelApiHandler();
     const server = createServer((req, res) => {
+        if (req.url?.startsWith('/api/')) {
+            void modelApi(req, res);
+            return;
+        }
         const url = req.url ?? '/';
         const method = req.method ?? 'GET';
         if (method !== 'GET' || !(url === '/' || url === '/index.html')) {

package/dist/init/execute.js

@@ -8,6 +8,7 @@ import { installGuardHook, installRefreshHook } from '../lib/hooks.js';
 import { injectBlock } from '../lib/markers.js';
 import { applyPluginEntry } from '../lib/opencode.js';
 import { OwnershipError, renderSkill } from '../lib/ownership.js';
+import { writeRouterConfig } from '../models/install.js';
 import { addDevDependencies, mergeScripts, WANTED_DEVS, WANTED_SCRIPTS, } from '../lib/pkgjson.js';
 import { installCmdsFor } from '../lib/pm.js';
 import { resolveBacklogBin, runCapture } from '../lib/run.js';
@@ -216,6 +217,17 @@ export async function executeActions(cwd, actions, ctx) {
             case 'generate-dashboard':
                 (await applyGenerateDashboard(cwd, warnings)) ? applied++ : skipped++;
                 break;
+            case 'install-model-router': {
+                const { installOpenCodeAdapter } = await import('../models/opencode.js');
+                const { installClaudeAdapter } = await import('../models/claude.js');
+                writeRouterConfig(cwd, action.enabled);
+                if (action.enabled) {
+                    installOpenCodeAdapter(cwd);
+                    installClaudeAdapter(cwd);
+                }
+                applied++;
+                break;
+            }
             case 'write':
                 atomicWrite(join(cwd, action.path), action.contents);
                 applied++;

package/dist/init/planner.js

@@ -56,5 +56,7 @@ export function planInit(state, opts, _version) {
         actions.push({ kind: 'install-refresh-hook' });
     if (opts.dashboard)
         actions.push({ kind: 'generate-dashboard' });
+    if (opts.models === true)
+        actions.push({ kind: 'install-model-router', enabled: true });
     return { actions, warnings };
 }

package/dist/models/claude.js

@@ -0,0 +1,61 @@
+// src/models/claude.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { atomicWrite } from '../lib/atomic.js';
+import { loadConfig } from './config.js';
+import { resolveTier } from './resolve.js';
+const MODEL_RE = /^model:\s*.+$/m;
+export function syncClaudeAgents(cwd, mainModel) {
+    const cfg = loadConfig(cwd);
+    if (!cfg.enabled)
+        return;
+    const workhorse = mainModel ? resolveTier(mainModel, 'workhorse', cfg) : cfg.resolved.workhorse || null;
+    const budget = mainModel ? resolveTier(mainModel, 'budget', cfg) : cfg.resolved.budget || null;
+    updateAgentFile(cwd, 'sbl-worker.md', workhorse);
+    updateAgentFile(cwd, 'sbl-worker-cheap.md', budget);
+}
+export function updateAgentFile(cwd, file, model) {
+    const path = join(cwd, '.claude', 'agents', file);
+    if (!existsSync(path))
+        return;
+    let content = readFileSync(path, 'utf8');
+    const replacement = `model: ${model ?? 'inherit'}`;
+    if (MODEL_RE.test(content)) {
+        content = content.replace(MODEL_RE, replacement);
+    }
+    else {
+        content = content.replace(/^---$/m, `---\n${replacement}`);
+    }
+    atomicWrite(path, content);
+}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function installClaudeAdapter(cwd) {
+    const workerPath = join(cwd, '.claude', 'agents', 'sbl-worker.md');
+    const cheapPath = join(cwd, '.claude', 'agents', 'sbl-worker-cheap.md');
+    atomicWrite(workerPath, readFileSync(join(__dirname, '../templates/claude-agent-sbl-worker.md'), 'utf8'));
+    atomicWrite(cheapPath, readFileSync(join(__dirname, '../templates/claude-agent-sbl-worker-cheap.md'), 'utf8'));
+    installSettingsHook(cwd);
+}
+function installSettingsHook(cwd) {
+    const path = join(cwd, '.claude', 'settings.json');
+    const existing = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : {};
+    const hook = {
+        hooks: {
+            SessionStart: [
+                {
+                    matcher: '*',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: 'node',
+                            args: ['node_modules/super-backlog/dist/templates/cc-session-hook.js'],
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    const next = { ...existing, hooks: { ...existing.hooks, ...hook.hooks } };
+    atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
+}

package/dist/models/config.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_CONFIG, DEFAULT_FAMILIES } from './defaults.js';
+const CONFIG_PATH = '.super-backlog/models.json';
+export function loadConfig(cwd) {
+    const path = join(cwd, CONFIG_PATH);
+    if (!existsSync(path))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (!raw || typeof raw !== 'object')
+            return { ...DEFAULT_CONFIG };
+        return normalizeConfig(raw);
+    }
+    catch {
+        return { ...DEFAULT_CONFIG, enabled: false };
+    }
+}
+export function normalizeConfig(partial) {
+    return {
+        version: typeof partial.version === 'number' ? partial.version : DEFAULT_CONFIG.version,
+        enabled: partial.enabled === true,
+        mode: ['auto', 'family', 'individual'].includes(partial.mode) ? partial.mode : 'family',
+        tiers: partial.tiers && typeof partial.tiers === 'object' ? partial.tiers : {},
+        individual: partial.individual && typeof partial.individual === 'object' ? partial.individual : {},
+        families: partial.families && typeof partial.families === 'object' ? partial.families : {},
+        resolved: partial.resolved && typeof partial.resolved === 'object' ? partial.resolved : {},
+    };
+}
+export function getFamilyTable(config) {
+    const merged = {};
+    for (const [name, tiers] of Object.entries(DEFAULT_FAMILIES)) {
+        merged[name] = { ...tiers, ...(config.families[name] || {}) };
+    }
+    for (const [name, tiers] of Object.entries(config.families)) {
+        if (!merged[name])
+            merged[name] = { workhorse: '', budget: '', ...tiers };
+    }
+    return merged;
+}

package/dist/models/dashboard-api.js

@@ -0,0 +1,30 @@
+import process from 'node:process';
+import { loadConfig } from './config.js';
+import { discoverModels } from './discovery.js';
+function currentCwd() {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return '.';
+    }
+}
+export function createModelApiHandler() {
+    return async (req, res) => {
+        const url = req.url ?? '/';
+        const method = req.method ?? 'GET';
+        if (method === 'GET' && url === '/api/models') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ config: loadConfig(currentCwd()), status: 'ok' }));
+            return;
+        }
+        if (method === 'POST' && url === '/api/models/discover') {
+            const result = await discoverModels(currentCwd());
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(result ?? { error: 'discovery failed' }));
+            return;
+        }
+        res.writeHead(404, { 'content-type': 'text/plain' });
+        res.end('not found');
+    };
+}

package/dist/models/defaults.js

@@ -0,0 +1,16 @@
+export const DEFAULT_FAMILIES = {
+    kimi: { workhorse: 'opencode/kimi-k2.7-code', budget: 'opencode/kimi-k2.5' },
+    grok: { workhorse: 'xai/grok-4.5', budget: 'xai/grok-4.3' },
+    claude: { workhorse: 'opencode/claude-sonnet-4-6', budget: 'opencode/claude-haiku-4-5' },
+    gpt: { workhorse: 'opencode/gpt-5.1-codex-mini', budget: 'opencode/gpt-5-nano' },
+    gemini: { workhorse: 'opencode/gemini-3.5-flash', budget: 'opencode/gemini-3.5-flash-lite' },
+};
+export const DEFAULT_CONFIG = {
+    version: 1,
+    enabled: false,
+    mode: 'family',
+    tiers: {},
+    individual: {},
+    families: {},
+    resolved: {},
+};

package/dist/models/discovery.js

@@ -0,0 +1,66 @@
+import { runCapture } from '../lib/run.js';
+export function parseOpenCodeModels(output) {
+    return output
+        .split('\n')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0 && s.includes('/'));
+}
+function scoreForTier(modelId, tier) {
+    const lower = modelId.toLowerCase();
+    // Prefer flagship-ish names for workhorse, avoid 'nano/lite' for workhorse
+    if (tier === 'workhorse') {
+        if (lower.includes('opus'))
+            return 100;
+        if (lower.includes('sonnet'))
+            return 90;
+        if (lower.includes('k2.7-code') || lower.includes('k2.6-code'))
+            return 85;
+        if (lower.includes('gpt-5.1') || lower.includes('gpt-5.2') || lower.includes('k3'))
+            return 80;
+        if (lower.includes('gemini-3.1') || lower.includes('gemini-3.5') || lower.includes('gemini-3.6'))
+            return 70;
+        if (lower.includes('k2.7') || lower.includes('k2.6'))
+            return 60;
+        if (lower.includes('grok-4.6'))
+            return 55;
+        if (lower.includes('grok-4.5'))
+            return 50;
+        return 10;
+    }
+    // Budget tier: prefer nano/lite/flash names
+    if (lower.includes('nano') || lower.includes('lite'))
+        return 100;
+    if (lower.includes('flash'))
+        return 90;
+    if (lower.includes('haiku'))
+        return 85;
+    if (lower.includes('k2.5'))
+        return 80;
+    if (lower.includes('grok-4.3'))
+        return 70;
+    return 10;
+}
+export function rankTiers(available) {
+    const workhorse = [...available].sort((a, b) => scoreForTier(b, 'workhorse') - scoreForTier(a, 'workhorse'))[0] || '';
+    const budget = [...available].sort((a, b) => scoreForTier(b, 'budget') - scoreForTier(a, 'budget'))[0] || '';
+    return { workhorse, budget };
+}
+export async function discoverModels(cwd) {
+    try {
+        const result = runCapture('opencode', ['models'], cwd);
+        if (result.status !== 0)
+            return null;
+        const available = parseOpenCodeModels(result.stdout);
+        if (available.length === 0)
+            return null;
+        const ranked = rankTiers(available);
+        return {
+            discoveredAt: new Date().toISOString(),
+            workhorse: ranked.workhorse,
+            budget: ranked.budget,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/models/family.js

@@ -0,0 +1,14 @@
+export function detectFamily(modelId) {
+    const lower = modelId.toLowerCase();
+    if (lower.includes('kimi'))
+        return 'kimi';
+    if (lower.includes('grok'))
+        return 'grok';
+    if (lower.includes('claude'))
+        return 'claude';
+    if (lower.includes('gemini'))
+        return 'gemini';
+    if (lower.includes('gpt'))
+        return 'gpt';
+    return null;
+}

package/dist/models/install.js

@@ -0,0 +1,18 @@
+// src/models/install.ts
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWrite } from '../lib/atomic.js';
+import { loadConfig } from './config.js';
+const CONFIG_DIR = '.super-backlog';
+const CONFIG_FILE = 'models.json';
+export function writeRouterConfig(cwd, enabled) {
+    const dir = join(cwd, CONFIG_DIR);
+    const path = join(dir, CONFIG_FILE);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const current = loadConfig(cwd);
+    const next = { ...current, enabled };
+    atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
+    return true;
+}

package/dist/models/opencode.js

@@ -0,0 +1,14 @@
+// src/models/opencode.ts
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { atomicWrite } from '../lib/atomic.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function installOpenCodeAdapter(cwd) {
+    const pluginPath = join(cwd, '.opencode', 'plugins', 'sbl-model-router.js');
+    const workerPath = join(cwd, '.opencode', 'agents', 'sbl-worker.md');
+    const cheapPath = join(cwd, '.opencode', 'agents', 'sbl-worker-cheap.md');
+    atomicWrite(pluginPath, readFileSync(join(__dirname, '../templates/model-router-plugin.js'), 'utf8'));
+    atomicWrite(workerPath, readFileSync(join(__dirname, '../templates/agent-sbl-worker.md'), 'utf8'));
+    atomicWrite(cheapPath, readFileSync(join(__dirname, '../templates/agent-sbl-worker-cheap.md'), 'utf8'));
+}

package/dist/models/resolve.js

@@ -0,0 +1,22 @@
+import { getFamilyTable } from './config.js';
+import { detectFamily } from './family.js';
+export { detectFamily } from './family.js';
+export function resolveTier(mainModel, tier, config) {
+    if (!config.enabled)
+        return null;
+    if (config.mode === 'individual') {
+        return config.individual[tier] || null;
+    }
+    const family = detectFamily(mainModel);
+    if (!family)
+        return null;
+    if (config.mode === 'family') {
+        const table = getFamilyTable(config);
+        const entry = table[family];
+        if (!entry)
+            return null;
+        return config.tiers[tier] || entry[tier] || null;
+    }
+    // auto mode falls back to family table when discovery is not populated
+    return config.resolved[tier] || config.tiers[tier] || null;
+}

package/dist/models/types.js

@@ -0,0 +1 @@
+export { DEFAULT_CONFIG } from './defaults.js';

package/dist/models/uninstall.js

@@ -0,0 +1,91 @@
+// src/models/uninstall.ts
+import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWrite } from '../lib/atomic.js';
+const ROUTER_FILES = [
+    '.super-backlog/models.json',
+    '.opencode/plugins/sbl-model-router.js',
+    '.opencode/agents/sbl-worker.md',
+    '.opencode/agents/sbl-worker-cheap.md',
+    '.claude/agents/sbl-worker.md',
+    '.claude/agents/sbl-worker-cheap.md',
+];
+export function uninstallModelRouter(cwd, report) {
+    for (const rel of ROUTER_FILES) {
+        const abs = join(cwd, rel);
+        if (!existsSync(abs)) {
+            report.push({ verdict: 'skipped', label: `${rel} (not found)` });
+            continue;
+        }
+        rmSync(abs, { force: true });
+        report.push({ verdict: 'removed', label: rel });
+    }
+    // Remove .super-backlog directory if it is now empty
+    const dir = join(cwd, '.super-backlog');
+    if (existsSync(dir)) {
+        try {
+            const remaining = readdirSync(dir);
+            if (remaining.length === 0) {
+                rmSync(dir, { recursive: true, force: true });
+                report.push({ verdict: 'removed', label: '.super-backlog/' });
+            }
+            else {
+                report.push({ verdict: 'kept', label: '.super-backlog/ (contains other files)' });
+            }
+        }
+        catch {
+            // ignore race conditions
+        }
+    }
+    uninstallClaudeSettingsHook(cwd, report);
+}
+function uninstallClaudeSettingsHook(cwd, report) {
+    const path = join(cwd, '.claude', 'settings.json');
+    if (!existsSync(path)) {
+        report.push({ verdict: 'skipped', label: '.claude/settings.json model-router hook (not found)' });
+        return;
+    }
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        report.push({ verdict: 'skipped', label: '.claude/settings.json (not valid JSON)' });
+        return;
+    }
+    const before = JSON.stringify(settings);
+    const sessionStart = settings.hooks?.SessionStart;
+    if (!Array.isArray(sessionStart) || sessionStart.length === 0) {
+        report.push({ verdict: 'skipped', label: '.claude/settings.json SessionStart hook (none)' });
+        return;
+    }
+    const filtered = sessionStart.filter((entry) => {
+        const hooks = entry.hooks;
+        if (!Array.isArray(hooks))
+            return true;
+        return !hooks.some((h) => typeof h === 'object' &&
+            h !== null &&
+            h.type === 'command' &&
+            Array.isArray(h.args) &&
+            String(h.args?.[0] ?? '').includes('cc-session-hook.js'));
+    });
+    if (filtered.length === sessionStart.length) {
+        report.push({ verdict: 'skipped', label: '.claude/settings.json SessionStart hook (none owned)' });
+        return;
+    }
+    if (filtered.length === 0) {
+        delete settings.hooks.SessionStart;
+        if (Object.keys(settings.hooks ?? {}).length === 0)
+            delete settings.hooks;
+    }
+    else {
+        settings.hooks.SessionStart = filtered;
+    }
+    if (JSON.stringify(settings) !== before) {
+        atomicWrite(path, `${JSON.stringify(settings, null, 2)}\n`);
+        report.push({ verdict: 'removed', label: '.claude/settings.json SessionStart hook' });
+    }
+    else {
+        report.push({ verdict: 'skipped', label: '.claude/settings.json SessionStart hook (none owned)' });
+    }
+}

package/dist/templates/agent-sbl-worker-cheap.md

@@ -0,0 +1,6 @@
+---
+name: sbl-worker-cheap
+description: Runs spikes, trivial edits, and mechanical searches. Use for fast, cheap work.
+mode: subagent
+---
+Complete the requested lightweight task as cheaply and correctly as possible.

package/dist/templates/agent-sbl-worker.md

@@ -0,0 +1,6 @@
+---
+name: sbl-worker
+description: Runs bounded implementation tasks. Use via the task tool for well-scoped code changes.
+mode: subagent
+---
+Implement the requested bounded change following project conventions and the existing codebase patterns.

package/dist/templates/cc-session-hook.js

@@ -0,0 +1,26 @@
+// src/templates/cc-session-hook.js
+import { loadConfig } from 'super-backlog/dist/models/config.js';
+import { resolveTier } from 'super-backlog/dist/models/resolve.js';
+import { updateAgentFile } from 'super-backlog/dist/models/claude.js';
+
+async function main() {
+  try {
+    let input = '';
+    process.stdin.on('data', (d) => { input += d; });
+    await new Promise((resolve) => process.stdin.on('end', resolve));
+    let event = {};
+    try { event = JSON.parse(input); } catch { /* ignore */ }
+    const cwd = process.cwd();
+    const cfg = loadConfig(cwd);
+    if (!cfg.enabled) process.exit(0);
+    const mainModel = event.model;
+    if (!mainModel || typeof mainModel !== 'string') process.exit(0);
+    updateAgentFile(cwd, 'sbl-worker.md', resolveTier(mainModel, 'workhorse', cfg));
+    updateAgentFile(cwd, 'sbl-worker-cheap.md', resolveTier(mainModel, 'budget', cfg));
+  } catch {
+    // degrade silently so a broken router never blocks Claude Code startup
+  }
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/dist/templates/claude-agent-sbl-worker-cheap.md

@@ -0,0 +1,6 @@
+---
+name: sbl-worker-cheap
+description: Runs spikes, trivial edits, and mechanical searches. Use for fast, cheap work.
+model: TIER_PLACEHOLDER
+---
+Complete the requested lightweight task as cheaply and correctly as possible.

package/dist/templates/claude-agent-sbl-worker.md

@@ -0,0 +1,6 @@
+---
+name: sbl-worker
+description: Runs bounded implementation tasks. Use via the Agent tool for well-scoped code changes.
+model: TIER_PLACEHOLDER
+---
+Implement the requested bounded change following project conventions and the existing codebase patterns.

package/dist/templates/model-router-plugin.js

@@ -0,0 +1,27 @@
+// src/templates/model-router-plugin.js
+module.exports = async () => {
+  const { loadConfig } = await import('super-backlog/dist/models/config.js');
+  const { resolveTier } = await import('super-backlog/dist/models/resolve.js');
+
+  const TIER_BY_AGENT = {
+    'sbl-worker': 'workhorse',
+    'sbl-worker-cheap': 'budget',
+    'explore': 'budget',
+  };
+
+  return {
+    'chat.params': async (input, output) => {
+      const cfg = loadConfig(input.cwd ?? process.cwd());
+      if (!cfg.enabled) return;
+      const agent = input.agent?.name;
+      const tier = TIER_BY_AGENT[agent];
+      if (!tier) return;
+      const mainModel = input.model;
+      if (!mainModel || typeof mainModel !== 'string') return;
+      const target = resolveTier(mainModel, tier, cfg);
+      if (!target) return;
+      output.params = output.params || {};
+      output.params.model = target;
+    },
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-backlog",
-  "version": "0.3.4",
+  "version": "0.5.0",
   "description": "One command to equip any project with Backlog.md + Superpowers, plus a Project Dashboard.",
   "license": "MIT",
   "repository": {