@bahulam/code 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Bahulam Code — abundance, in your terminal. CLI-first, reliability-first, sub-agents, 65.6% SWE-bench Verified.",
   "type": "module",
   "bin": {

package/src/config/model-defaults-default.json

@@ -0,0 +1,9 @@
+{
+  "schema": "bahulam.model_defaults.v1",
+  "source": "codekepler-backend/app/services/model_defaults.py",
+  "defaults": {
+    "reasoning": "deepseek/deepseek-v4-flash",
+    "fast": "deepseek/deepseek-v4-flash",
+    "planning": "deepseek/deepseek-v4-pro"
+  }
+}

package/src/config/model-defaults.mjs

@@ -0,0 +1,42 @@
+/**
+ * Shipped npm-side model defaults.
+ *
+ * Source of truth is backend `app/services/model_defaults.py`; release sync
+ * writes `model-defaults-default.json` next to the shipped catalog.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const FALLBACK_MODEL_DEFAULTS = Object.freeze({
+  reasoning: 'deepseek/deepseek-v4-flash',
+  fast: 'deepseek/deepseek-v4-flash',
+  planning: 'deepseek/deepseek-v4-pro',
+});
+
+const _dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULTS_PATH = path.join(_dirname, 'model-defaults-default.json');
+
+function clean(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+export function readShippedModelDefaults() {
+  try {
+    const data = JSON.parse(fs.readFileSync(DEFAULTS_PATH, 'utf-8'));
+    const defaults = data?.defaults && typeof data.defaults === 'object' ? data.defaults : {};
+    return {
+      reasoning: clean(defaults.reasoning) || FALLBACK_MODEL_DEFAULTS.reasoning,
+      fast: clean(defaults.fast) || FALLBACK_MODEL_DEFAULTS.fast,
+      planning: clean(defaults.planning) || FALLBACK_MODEL_DEFAULTS.planning,
+    };
+  } catch {
+    return { ...FALLBACK_MODEL_DEFAULTS };
+  }
+}
+
+export const SHIPPED_MODEL_DEFAULTS = readShippedModelDefaults();
+export const DEFAULT_REASONING_MODEL = SHIPPED_MODEL_DEFAULTS.reasoning;
+export const DEFAULT_FAST_MODEL = SHIPPED_MODEL_DEFAULTS.fast;
+export const DEFAULT_PLANNING_MODEL = SHIPPED_MODEL_DEFAULTS.planning;

package/src/config/settings.mjs

@@ -7,6 +7,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { DEFAULT_FAST_MODEL, DEFAULT_REASONING_MODEL } from './model-defaults.mjs';
 
 /**
  * Full settings schema with defaults.
@@ -30,9 +31,9 @@ export const SETTINGS_SCHEMA = {
         Stop: [],
         SessionStart: [],
     },
-    model: 'claude-sonnet-4-6',
+    model: DEFAULT_REASONING_MODEL,
     subagentModel: null,
-    fastModel: 'claude-haiku-4-5',
+    fastModel: DEFAULT_FAST_MODEL,
     fastMode: false,
     alwaysThinkingEnabled: false,
     autoCompactEnabled: true,

package/src/core/lint-resolver.mjs

@@ -68,7 +68,12 @@ export function resolveLintCommand(targetPath, {
         return resolvePythonLint(target, { stat, root });
     }
     if (language === 'typescript') {
-        return resolveJavaScriptLint(target, { stat, root, typescript: true });
+        return resolveJavaScriptLint(target, {
+            stat,
+            root,
+            typescript: true,
+            preferTypeCheck: !allowProjectScript,
+        });
     }
     if (language === 'javascript') {
         return resolveJavaScriptLint(target, { stat, root, typescript: false });
@@ -279,7 +284,47 @@ function captured(command) {
     return `${command} 2>&1 || true`;
 }
 
-function resolveJavaScriptLint(target, { stat, root, typescript }) {
+function resolveTypeScriptProjectCheck(target, { stat, root }) {
+    const baseDir = stat?.isDirectory() ? target : path.dirname(target);
+    const tsconfig = findUpFile(baseDir, root, ['tsconfig.json']);
+    if (!tsconfig) return null;
+    const cwd = path.dirname(tsconfig);
+    const hasTypescript = hasNodeTool(baseDir, root, 'tsc', ['typescript']);
+    if (!hasTypescript) return null;
+    return {
+        command: captured(`npx --no-install tsc --noEmit --pretty false -p ${shellPathArg(tsconfig, cwd)}`),
+        cwd,
+        language: 'typescript',
+        target,
+        scope: 'project',
+        source: 'typescript',
+        reason: 'tsconfig project check',
+    };
+}
+
+export function normalizeLintOutput(lint, { stdout = '', stderr = '', errored = false } = {}) {
+    const output = String(errored ? (stderr || stdout || '') : (stdout || stderr || '')).trim();
+    if (!output) return null;
+    if (lint?.source !== 'eslint' || !/Oops!\s+Something went wrong!/i.test(output)) {
+        return output;
+    }
+    const lines = output.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+    const detail = lines.find(line => (
+        !/^Oops!/i.test(line) &&
+        !/^ESLint:/i.test(line) &&
+        !/^If you still have problems/i.test(line) &&
+        !/^Please include/i.test(line)
+    ));
+    const suffix = detail ? ` ${detail}` : ' Check the project ESLint config, parser, and plugins.';
+    return `eslint failed:${suffix}`;
+}
+
+function resolveJavaScriptLint(target, { stat, root, typescript, preferTypeCheck = false }) {
+    if (typescript && preferTypeCheck) {
+        const typecheck = resolveTypeScriptProjectCheck(target, { stat, root });
+        if (typecheck) return typecheck;
+    }
+
     const baseDir = stat?.isDirectory() ? target : path.dirname(target);
     const eslintReady = hasConfig(baseDir, root, ESLINT_CONFIGS) ||
         hasNodeTool(baseDir, root, 'eslint', ['eslint']);
@@ -312,20 +357,7 @@ function resolveJavaScriptLint(target, { stat, root, typescript }) {
     }
 
     if (typescript) {
-        const tsconfig = findUpFile(baseDir, root, ['tsconfig.json']);
-        if (!tsconfig) return null;
-        const cwd = path.dirname(tsconfig);
-        const hasTypescript = hasNodeTool(baseDir, root, 'tsc', ['typescript']);
-        if (!hasTypescript) return null;
-        return {
-            command: captured(`npx --no-install tsc --noEmit --pretty false -p ${shellPathArg(tsconfig, cwd)}`),
-            cwd,
-            language: 'typescript',
-            target,
-            scope: 'project',
-            source: 'typescript',
-            reason: 'tsconfig project check',
-        };
+        return resolveTypeScriptProjectCheck(target, { stat, root });
     }
 
     const ext = path.extname(target).toLowerCase();

package/src/core/tasks.mjs

@@ -16,6 +16,9 @@ const DEFAULT_CONTENT = Object.freeze({
   'done.md': '# Done\n\n',
 });
 
+const MANAGED_START = '<!-- bahulam:todo-write:start -->';
+const MANAGED_END = '<!-- bahulam:todo-write:end -->';
+
 export function ensureTaskFiles({ cwd = process.cwd() } = {}) {
   const dir = path.join(cwd, '.bahulam', 'tasks');
   fs.mkdirSync(dir, { recursive: true });
@@ -125,6 +128,38 @@ export function taskCounts(board) {
   );
 }
 
+export function syncTodoWriteToTaskFiles({ cwd = process.cwd(), todos = [] } = {}) {
+  ensureTaskFiles({ cwd });
+  const grouped = { active: [], backlog: [], blocked: [], done: [] };
+  for (const todo of Array.isArray(todos) ? todos : []) {
+    const text = String(todo?.content || '').trim();
+    if (!text) continue;
+    const status = String(todo?.status || 'pending').toLowerCase();
+    const list = status === 'completed'
+      ? 'done'
+      : status === 'in_progress'
+        ? 'active'
+        : 'backlog';
+    grouped[list].push({ text, checked: list === 'done' });
+  }
+
+  const written = [];
+  for (const [list, fileName] of Object.entries(TASK_FILES)) {
+    const filePath = path.join(cwd, '.bahulam', 'tasks', fileName);
+    const existing = readText(filePath) || DEFAULT_CONTENT[fileName] || `# ${list}\n\n`;
+    const managed = grouped[list]
+      .map(task => taskLine(task.text, list, task.checked))
+      .join('\n');
+    const block = `${MANAGED_START}\n${managed}${managed ? '\n' : ''}${MANAGED_END}`;
+    const next = replaceManagedBlock(existing, block);
+    if (next !== existing) {
+      fs.writeFileSync(filePath, next);
+      written.push(filePath);
+    }
+  }
+  return { written, counts: Object.fromEntries(Object.entries(grouped).map(([list, items]) => [list, items.length])) };
+}
+
 export function normalizeList(value) {
   const key = String(value || '').toLowerCase();
   if (key === 'todo' || key === 'pending') return 'backlog';
@@ -149,6 +184,18 @@ function taskLine(text, list, checked = false) {
   return `- [${mark}] ${text}`;
 }
 
+function replaceManagedBlock(content, block) {
+  const value = String(content || '');
+  const pattern = new RegExp(`${escapeRegExp(MANAGED_START)}[\\s\\S]*?${escapeRegExp(MANAGED_END)}`);
+  if (pattern.test(value)) return value.replace(pattern, block);
+  const trimmed = value.replace(/\s*$/, '');
+  return `${trimmed}\n\n${block}\n`;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 function readText(filePath) {
   try {
     return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';

package/src/core/tool-executor.mjs

@@ -28,7 +28,7 @@ import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
 import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
 import { backgroundTasks } from './background-tasks.mjs';
-import { resolveLintCommand } from './lint-resolver.mjs';
+import { normalizeLintOutput, resolveLintCommand } from './lint-resolver.mjs';
 import { PluginRegistry } from '../plugins/registry.mjs';
 import { loadPluginTool } from '../plugins/executor.mjs';
 import * as fs from 'node:fs';
@@ -137,7 +137,8 @@ export function createToolExecutor({
             });
     }
     let _searchCodeUsed = false; // tracks if search_code was called (for read_file nudge)
-    let _readOnlyCacheGeneration = 0;
+    let _structureCacheGeneration = 0;
+    let _searchCacheGeneration = 0;
     const readOnlyResultCache = new Map();
 
     function resolvePath(p, args = {}, options = {}) {
@@ -339,11 +340,12 @@ export function createToolExecutor({
         );
     }
 
-    function updateProjectIndex(filePath) {
+    function updateProjectIndex(filePath, { contentChanged = true, structureChanged = false } = {}) {
         try {
             projectRegistry.projectForPath(filePath)?.retriever.updateFile(filePath);
         } catch { /* best effort */ }
-        _readOnlyCacheGeneration++;
+        if (contentChanged) _searchCacheGeneration++;
+        if (structureChanged) _structureCacheGeneration++;
     }
 
     function readTextIfExists(filePath) {
@@ -390,7 +392,6 @@ export function createToolExecutor({
             kind,
             args,
             fingerprint,
-            generation: _readOnlyCacheGeneration,
         }));
     }
 
@@ -498,9 +499,11 @@ export function createToolExecutor({
                 maxBuffer: 1_000_000,
                 env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', TERM: 'dumb' },
             }, (err, stdout = '', stderr = '') => {
-                const output = err
-                    ? stripAnsi(stderr || stdout || '').trim()
-                    : stripAnsi(stdout || stderr || '').trim();
+                const output = normalizeLintOutput(lint, {
+                    stdout: stripAnsi(stdout),
+                    stderr: stripAnsi(stderr),
+                    errored: Boolean(err),
+                });
                 resolve(output || null);
             });
         });
@@ -920,6 +923,28 @@ export function createToolExecutor({
             };
         },
 
+        TodoWrite: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const result = await occRegistry.call('TodoWrite', args || {}, {
+                ...options,
+                cwd: process.cwd(),
+                onTaskFilesWritten: (files) => {
+                    for (const file of Array.isArray(files) ? files : []) {
+                        updateProjectIndex(file, { contentChanged: true, structureChanged: true });
+                    }
+                },
+            });
+            return {
+                success: !/^Validation error:/i.test(String(result || '')),
+                output: String(result || ''),
+                _tool: 'TodoWrite',
+            };
+        },
+
+        todo_write: async (args, options = {}) => {
+            return toolMap.TodoWrite(args, options);
+        },
+
         // Reserved meta-tool adapter. Cloud backends may implement Delegate
         // natively; local callbacks use this to route through the exact same
         // registry + dispatch funnel as /run and workflows.
@@ -1421,6 +1446,7 @@ export function createToolExecutor({
                 return { success: false, output: `Error: Invalid file path "${rawPath || ''}". Register the project, then use an absolute path.`, _tool: 'write_file' };
             }
             const filePath = await resolvePath(rawPath, args, { allowMissing: true });
+            const existedBefore = fs.existsSync(filePath);
             const before = readTextIfExists(filePath);
             const writeCheck = validateWrite(filePath, args.content, projectRootFor(filePath));
             if (!writeCheck.safe) {
@@ -1443,7 +1469,10 @@ export function createToolExecutor({
             const wrapped = wrapResult(result, 'write_file');
             const after = readTextIfExists(filePath);
             attachFileDiff(wrapped, filePath, before, after);
-            updateProjectIndex(filePath);
+            updateProjectIndex(filePath, {
+                contentChanged: before !== after,
+                structureChanged: !existedBefore && fs.existsSync(filePath),
+            });
 
             // Auto-lint the written file
             const lintOutput = await autoLint(filePath);
@@ -1489,6 +1518,7 @@ export function createToolExecutor({
                     // Ensure parent directory exists
                     const dir = path.dirname(filePath);
                     fs.mkdirSync(dir, { recursive: true });
+                    const existedBefore = fs.existsSync(filePath);
                     const before = readTextIfExists(filePath);
 
                     // Read first if exists (OCC Write requirement)
@@ -1501,7 +1531,10 @@ export function createToolExecutor({
                     await occRegistry.call('write_file', { file_path: filePath, content });
                     const after = readTextIfExists(filePath);
                     diffs.push(buildResultFileDiff(filePath, before, after));
-                    updateProjectIndex(filePath);
+                    updateProjectIndex(filePath, {
+                        contentChanged: before !== after,
+                        structureChanged: !existedBefore && fs.existsSync(filePath),
+                    });
                     results.push(rawPath);
                 } catch (err) {
                     errors.push(`${rawPath}: ${err.message}`);
@@ -1615,7 +1648,7 @@ export function createToolExecutor({
                 };
             }
             attachFileDiff(wrapped, filePath, before, after);
-            updateProjectIndex(filePath);
+            updateProjectIndex(filePath, { contentChanged: before !== after, structureChanged: false });
             _hasEdited = true;
 
             // Auto-lint the edited file
@@ -1643,7 +1676,7 @@ export function createToolExecutor({
                     format: args.format || (args.tree === true ? 'tree' : 'glob'),
                     max_depth: args.max_depth ?? args.maxDepth ?? null,
                 },
-                { generation: _readOnlyCacheGeneration },
+                { structureGeneration: _structureCacheGeneration },
                 async () => {
                     if (args.format === 'tree' || args.tree === true) {
                         const requestedDepth = Number(args.max_depth ?? args.maxDepth ?? 2);
@@ -1764,7 +1797,7 @@ export function createToolExecutor({
                 return await withReadOnlyCache(
                     'search_files',
                     { query, path: searchPath, mode: 'glob' },
-                    { generation: _readOnlyCacheGeneration },
+                    { structureGeneration: _structureCacheGeneration },
                     async () => {
                         const result = await occRegistry.call('list_files', {
                             pattern: query,
@@ -1785,7 +1818,7 @@ export function createToolExecutor({
             return await withReadOnlyCache(
                 'search_files',
                 { query, path: searchPath, mode: 'grep' },
-                { generation: _readOnlyCacheGeneration },
+                { searchGeneration: _searchCacheGeneration },
                 async () => {
                     const result = await occRegistry.call('search_code', {
                         pattern: query,
@@ -1889,8 +1922,9 @@ export function createToolExecutor({
                 if (checkpoints) {
                     try { checkpoints.save(filePath); } catch { /* best effort */ }
                 }
+                const existedBefore = fs.existsSync(filePath);
                 fs.unlinkSync(filePath);
-                updateProjectIndex(filePath);
+                updateProjectIndex(filePath, { contentChanged: existedBefore, structureChanged: existedBefore });
                 return { success: true, message: `Deleted ${args.path}`, _tool: 'delete_file' };
             } catch (err) {
                 return { success: false, output: `Error: ${err.message}`, _tool: 'delete_file' };

package/src/terminal/main.mjs

@@ -380,7 +380,10 @@ async function main() {
     /help                   Show available commands
     /stats                  Session metrics (tokens, cost, tools)
     /cost                   Detailed cost breakdown by model
-    /model [role] [model]   Show or set session model override
+    /model                  Open interactive model overrides
+    /model status           Show model overrides and catalog source
+    /model refresh          Refresh model catalog from backend
+    /model list [category]  List curated platform models
     /history                Conversation history
     /new                    Start a new session
     /clear                  Clear conversation history

package/src/terminal/repl.mjs

@@ -412,8 +412,34 @@ const NAMED_MODEL_MODES = new Set(NAMED_MODEL_MODES_LIST);
 let _modelCatalogCache = null;
 let _modelCatalogError = null;
 let _modelCatalogSource = null;   // 'snapshot' | 'backend'
+let _modelCatalogFetchedAt = null;
 let _backendRefreshInFlight = null;
 
+function modelCatalogSummary(catalog = _modelCatalogCache) {
+  const rows = Array.isArray(catalog) ? catalog : [];
+  const curated = rows.filter(m => m?.harness_validated).length;
+  return { total: rows.length, curated };
+}
+
+function formatCatalogSource(source = _modelCatalogSource) {
+  if (source === 'backend') return 'backend';
+  if (source === 'snapshot') return 'shipped snapshot';
+  return 'unloaded';
+}
+
+function formatCatalogFetchedAt(value = _modelCatalogFetchedAt) {
+  if (!value) return 'not refreshed this session';
+  try {
+    return new Intl.DateTimeFormat(undefined, {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+    }).format(value);
+  } catch {
+    return value.toISOString();
+  }
+}
+
 async function fetchModelCatalog(ctx) {
   // Seed from the shipped snapshot so /model list, /model form and the
   // curation warnings work offline. The backend refresh below overlays
@@ -423,6 +449,7 @@ async function fetchModelCatalog(ctx) {
     if (shipped && shipped.length) {
       _modelCatalogCache = shipped;
       _modelCatalogSource = 'snapshot';
+      _modelCatalogFetchedAt = new Date();
       _modelCatalogError = null;
     }
   }
@@ -467,6 +494,7 @@ async function refreshCatalogFromBackend(ctx) {
     if (models && models.length) {
       _modelCatalogCache = models;
       _modelCatalogSource = 'backend';
+      _modelCatalogFetchedAt = new Date();
       _modelCatalogError = null;
     } else if (!_modelCatalogCache) {
       _modelCatalogError = models ? 'catalog is empty' : 'unexpected response shape';
@@ -565,6 +593,8 @@ async function printModelCatalog(ctx, filterCategory = null) {
   if (rest > 0) {
     process.stderr.write(`  ${c.dim(`+${rest} more models available on the BYOK route (--route byok, own API key)`)}\n`);
   }
+  const summary = modelCatalogSummary(catalog);
+  process.stderr.write(`  ${c.dim(`source: ${formatCatalogSource()} · ${summary.total} models · ${summary.curated} curated · refreshed ${formatCatalogFetchedAt()}`)}\n`);
   process.stderr.write('\n');
 }
 
@@ -611,7 +641,7 @@ function applyLaunchModelArgs(cliArgs, ctx) {
   return Promise.all(pending);
 }
 
-function printModelStatus() {
+async function printModelStatus(ctx = null) {
   process.stderr.write(`\n  ${c.bold('Models')}\n`);
   process.stderr.write(`  ${c.gray('─'.repeat(44))}\n`);
   process.stderr.write(`  ${c.gray('Active coding')} ${session.model || 'backend default'}\n`);
@@ -620,6 +650,17 @@ function printModelStatus() {
     process.stderr.write(`  ${c.gray('Mode         ')} ${session.modelMode}\n`);
   }
 
+  const catalog = await fetchModelCatalog(ctx);
+  const summary = modelCatalogSummary(catalog);
+  process.stderr.write(`\n  ${c.bold('Catalog')}\n`);
+  if (catalog) {
+    process.stderr.write(`  ${c.gray('Source       ')} ${formatCatalogSource()}\n`);
+    process.stderr.write(`  ${c.gray('Models       ')} ${summary.total} total · ${summary.curated} curated\n`);
+    process.stderr.write(`  ${c.gray('Refreshed    ')} ${formatCatalogFetchedAt()}\n`);
+  } else {
+    process.stderr.write(`  ${c.yellow('!')} ${c.dim(_modelCatalogError || 'unavailable')}\n`);
+  }
+
   const limits = session.modelLimits || {};
   const subAgentModels = session.subAgentModels || {};
   const planningModel = subAgentModels.plan || limits.planning?.model || limits.orchestrator?.model;
@@ -716,13 +757,13 @@ async function handleModelCommand(rest = '', ctx) {
     if (process.stdin.isTTY) {
       await openModelForm(ctx);
     } else {
-      printModelStatus();
+      await printModelStatus(ctx);
     }
     return;
   }
 
   if (parts[0] === 'status') {
-    printModelStatus();
+    await printModelStatus(ctx);
     return;
   }
 
@@ -751,8 +792,9 @@ async function handleModelCommand(rest = '', ctx) {
     _modelCatalogCache = null;
     _modelCatalogError = null;
     _modelCatalogSource = null;
+    _modelCatalogFetchedAt = null;
     _backendRefreshInFlight = null;
-    process.stderr.write(`  ${c.dim('Refreshing model catalog…')}\n`);
+    process.stderr.write(`  ${c.dim('Refreshing model catalog from backend…')}\n`);
     await refreshCatalogFromBackend(ctx);
     if (_modelCatalogSource !== 'backend') {
       // Backend fetch failed — restore the shipped snapshot so subsequent
@@ -761,8 +803,12 @@ async function handleModelCommand(rest = '', ctx) {
       if (shipped && shipped.length) {
         _modelCatalogCache = shipped;
         _modelCatalogSource = 'snapshot';
+        _modelCatalogFetchedAt = new Date();
       }
       process.stderr.write(`  ${c.yellow('!')} ${c.dim(`Backend refresh failed — ${_modelCatalogError || 'unknown error'}. Showing shipped snapshot.`)}\n`);
+    } else {
+      const summary = modelCatalogSummary();
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`Refreshed ${summary.total} models from backend · ${summary.curated} curated · ${formatCatalogFetchedAt()}`)}\n`);
     }
     await printModelCatalog(ctx);
     return;
@@ -1247,9 +1293,32 @@ async function handleSkillsCommand(rest = '', ctx) {
   printSkillsUsage();
 }
 
+const MODEL_COMMAND_COMPLETIONS = [
+  { command: '/model', description: 'Open interactive model overrides' },
+  { command: '/model status', description: 'Show model overrides and catalog source' },
+  { command: '/model refresh', description: 'Refresh model catalog from backend' },
+  { command: '/model list', description: 'List curated platform models' },
+  { command: '/model list text', description: 'List text models' },
+  { command: '/model list image', description: 'List image models' },
+  { command: '/model clear', description: 'Clear model overrides' },
+];
+
+function slashCompletionDescription(command) {
+  const modelHint = MODEL_COMMAND_COMPLETIONS.find(item => item.command === command);
+  if (modelHint) return modelHint.description;
+  return COMMANDS[command] || (command === '/quit' ? 'Exit CLI' : '');
+}
+
 function commandCompletions(line) {
-  if (line.startsWith('/help ')) {
-    const topic = line.slice('/help '.length).toLowerCase();
+  const text = String(line || '').trimStart();
+  if (text === '/model' || text.startsWith('/model ')) {
+    const modelCompletions = MODEL_COMMAND_COMPLETIONS
+      .map(item => item.command)
+      .filter(cmd => cmd.startsWith(text));
+    if (modelCompletions.length) return modelCompletions;
+  }
+  if (text.startsWith('/help ')) {
+    const topic = text.slice('/help '.length).toLowerCase();
     const categories = ['all', ...HELP_GROUPS.map(g => g.key)];
     const hits = categories.map(c => `/help ${c}`).filter(cmd => cmd.startsWith(`/help ${topic}`));
     return hits.length ? hits : categories.map(c => `/help ${c}`);
@@ -1260,19 +1329,19 @@ function commandCompletions(line) {
   // No fallback-to-all: a non-matching prefix ("/Users/...", a pasted
   // path) must yield NOTHING so the hint overlay hides, not the full
   // catalog. Bare "/" still matches every command via startsWith.
-  return all.filter(cmd => cmd.startsWith(line));
+  return all.filter(cmd => cmd.startsWith(text));
 }
 
 function slashCommandSuggestions(line, limit = 5) {
   const text = String(line || '').trimStart();
   if (!text.startsWith('/')) return [];
-  const partial = text.split(/\s+/)[0] || '/';
+  const partial = text.startsWith('/model ') ? text : (text.split(/\s+/)[0] || '/');
   return commandCompletions(partial)
     .filter(cmd => cmd.startsWith('/'))
     .slice(0, limit)
     .map(cmd => ({
       command: cmd,
-      description: COMMANDS[cmd] || (cmd === '/quit' ? 'Exit CLI' : ''),
+      description: slashCompletionDescription(cmd),
     }));
 }
 
@@ -1399,12 +1468,13 @@ function buildContextStrip() {
   return parts.join(c.dim(' · '));
 }
 
-// ── Dock meta line (cwd ⎇ branch · turn N) ─────────────────────────────
+// ── Dock meta line (cwd ⎇ branch · turn N · task …) ────────────────────
 //
-// The dock's meta row shows durable session context. Git branch is cached
-// so we don't shell out on every keystroke; refreshed at most every 5s.
+// The dock's meta row shows durable session context. Git branch and task
+// state are cached so we don't hit disk/shell on every keystroke.
 
 const _dockGitCache = { branch: null, at: 0, cwd: null };
+const _dockTaskCache = { summary: '', at: 0, cwd: null };
 
 function activeDockModel() {
   return session.modelOverrides?.reasoning
@@ -1438,6 +1508,36 @@ function _probeGitBranch(cwd) {
   return branch;
 }
 
+function compactTaskText(text, max = 36) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (value.length <= max) return value;
+  return value.slice(0, Math.max(0, max - 1)) + '…';
+}
+
+function _probeTaskSummary(cwd) {
+  const now = Date.now();
+  if (_dockTaskCache.cwd === cwd && (now - _dockTaskCache.at) < 1500) {
+    return _dockTaskCache.summary;
+  }
+  let summary = '';
+  try {
+    const board = loadTaskBoard({ cwd });
+    const counts = taskCounts(board);
+    const active = board.lists.active?.tasks?.find(task => !task.checked) || board.lists.active?.tasks?.[0];
+    if (active?.text) {
+      summary = `task ${compactTaskText(active.text)}`;
+    } else if (counts.blocked > 0 || counts.backlog > 0) {
+      summary = `tasks ${counts.active} active, ${counts.blocked} blocked, ${counts.backlog} backlog`;
+    }
+  } catch {
+    summary = '';
+  }
+  _dockTaskCache.cwd = cwd;
+  _dockTaskCache.at = now;
+  _dockTaskCache.summary = summary;
+  return summary;
+}
+
 function buildDockMeta() {
   const parts = [];
 
@@ -1446,6 +1546,9 @@ function buildDockMeta() {
   const branch = _probeGitBranch(cwd);
   parts.push(branch ? `${projectName} ⎇ ${branch}` : projectName);
 
+  const taskSummary = _probeTaskSummary(cwd);
+  if (taskSummary) parts.push(taskSummary);
+
   if (session.turns > 0) {
     parts.push(`turn ${session.turns}`);
   }
@@ -2236,6 +2339,9 @@ function renderEvent(event) {
     case 'tool_result':
     case 'tool_done': {
       const eventData = normalizeSubAgentRunData(data);
+      if (String(eventData?.tool || '').toLowerCase() === 'todowrite' || String(eventData?._tool || '').toLowerCase() === 'todowrite') {
+        _dockTaskCache.at = 0;
+      }
       if (watchState.active) {
         const success = eventData?.success !== false;
         watchState.addEntry('done', { label: eventData?.tool, detail: success ? '✓' : '✗' });
@@ -3062,6 +3168,7 @@ function refreshTaskContext(ctx) {
     const previous = ctx.latestProjectContext || null;
     ctx.latestProjectContext = loadProjectContext({ cwd: safeCwd(), previous });
     ctx.latestEnvelope = null;
+    _dockTaskCache.at = 0;
   } catch { /* best effort */ }
 }
 
@@ -5236,10 +5343,12 @@ export async function startTerminalRepl() {
   function selectedSlashCommandFor(line) {
     const input = String(line || '').trim();
     if (!input.startsWith('/')) return null;
-    if (COMMANDS[input] || input.startsWith('/help ')) return input;
+    const parts = input.split(/\s+/);
+    const firstToken = parts[0] || '';
+    if (COMMANDS[firstToken] || firstToken === '/help') return input;
     const item = slashHintItems[slashHintSelected];
     if (!item) return input;
-    return item.command;
+    return parts.length > 1 ? `${item.command} ${parts.slice(1).join(' ')}` : item.command;
   }
 
   function reservePromptBottomPadding() {

package/src/tools/agent.mjs

@@ -11,6 +11,7 @@
 import { createAgentLoop } from '../core/agent-loop.mjs';
 import { createToolRegistry } from './registry.mjs';
 import { createPermissionChecker } from '../permissions/checker.mjs';
+import { DEFAULT_REASONING_MODEL } from '../config/model-defaults.mjs';
 
 export const AgentTool = {
     name: 'Agent',
@@ -59,7 +60,7 @@ export const AgentTool = {
     _nextBgId: 0,
 
     async call(input, options = {}) {
-        const model = input.model || process.env.SUBAGENT_MODEL || 'claude-sonnet-4-6';
+        const model = input.model || process.env.SUBAGENT_MODEL || DEFAULT_REASONING_MODEL;
         const tools = createToolRegistry({
             pluginRegistry: options.pluginRegistry || null,
             stateEmit: options.stateEmit || null,

package/src/tools/todo-write.mjs

@@ -1,3 +1,5 @@
+import { syncTodoWriteToTaskFiles } from '../core/tasks.mjs';
+
 /**
  * TodoWrite Tool — in-memory task management.
  *
@@ -45,7 +47,7 @@ export const TodoWriteTool = {
         return [];
     },
 
-    async call(input) {
+    async call(input, options = {}) {
         // Replace entire todo list (matches Claude Code behavior)
         todos.length = 0;
         nextId = 1;
@@ -63,6 +65,17 @@ export const TodoWriteTool = {
             `[${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '~' : ' '}] ${t.id}. ${t.content} (${t.priority})`
         ).join('\n');
 
-        return `Updated ${todos.length} todos:\n${summary}`;
+        let syncLine = '';
+        try {
+            const synced = syncTodoWriteToTaskFiles({ cwd: options.cwd || process.cwd(), todos });
+            if (typeof options.onTaskFilesWritten === 'function') {
+                options.onTaskFilesWritten(synced.written);
+            }
+            syncLine = `\nSynced to .bahulam/tasks: ${synced.counts.active} active, ${synced.counts.backlog} backlog, ${synced.counts.done} done`;
+        } catch (err) {
+            syncLine = `\nTask markdown sync skipped: ${err.message || String(err)}`;
+        }
+
+        return `Updated ${todos.length} todos:\n${summary}${syncLine}`;
     },
 };

package/src/ui/commands.mjs

@@ -9,6 +9,7 @@ import { SessionManager } from '../core/session.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { readEnv, listEnvVars } from '../config/env.mjs';
 import * as telemetry from '../telemetry/index.mjs';
+import { DEFAULT_FAST_MODEL, DEFAULT_REASONING_MODEL } from '../config/model-defaults.mjs';
 
 const checkpoints = new CheckpointManager();
 let sessionManager = null;
@@ -134,12 +135,14 @@ export const COMMANDS = {
     '/fast': {
         description: 'Toggle fast mode (uses faster, cheaper model)',
         handler(args, state) {
-            if (state.model?.includes('haiku')) {
-                state.model = 'claude-sonnet-4-6';
-                return 'Fast mode OFF — using claude-sonnet-4-6';
+            if (state.fastMode) {
+                state.fastMode = false;
+                state.model = DEFAULT_REASONING_MODEL;
+                return `Fast mode OFF — using ${DEFAULT_REASONING_MODEL}`;
             }
-            state.model = 'claude-haiku-4-5';
-            return 'Fast mode ON — using claude-haiku-4-5';
+            state.fastMode = true;
+            state.model = DEFAULT_FAST_MODEL;
+            return `Fast mode ON — using ${DEFAULT_FAST_MODEL}`;
         },
     },
 

package/src/ui/input-dock.mjs

@@ -242,7 +242,7 @@ function overlayRowsForWrapped(wrappedLength, requestedMaxRows = DEFAULT_OVERLAY
 // takes over inside drawInputLines so at most inputRowsMax rows render.
 function computeInputRowsForBuffer(prefix, value) {
   const budget = inputTextBudget();
-  const wrapped = wrapToLines(`${prefix || ''}${value || ''}`, budget);
+  const wrapped = wrapToLines(`${prefix || ''}${value || ''}`, budget, { preserveTrailingWhitespace: true });
   const wanted = Math.max(MIN_INPUT_ROWS, wrapped.length);
   return Math.min(inputRowsMax, wanted);
 }
@@ -485,7 +485,7 @@ export function clearDockArea({ restore = true, geometry = null } = {}) {
 function layoutInput(prefix, value) {
   const budget = inputTextBudget();
   const combined = `${prefix || ''}${value || ''}`;
-  const wrapped = wrapToLines(combined, budget);
+  const wrapped = wrapToLines(combined, budget, { preserveTrailingWhitespace: true });
   const tail = tailWithEllipsis(wrapped, inputRows);
   return {
     lines: tail.visible,

package/src/ui/slash-commands.mjs

@@ -88,7 +88,11 @@ export const HELP_GROUPS = [
       ['/status context', 'Loaded .bahulam context'],
       ['/status metrics', 'Progress bars and runtime metrics'],
       ['/status cost', 'Credits and message window'],
-      ['/model [role] [model]', 'Show or set session model override'],
+      ['/model', 'Open interactive model overrides'],
+      ['/model status', 'Show model overrides and catalog source'],
+      ['/model refresh', 'Refresh model catalog from backend'],
+      ['/model list [category]', 'List curated platform models'],
+      ['/model [role] [model]', 'Set session model override'],
       ['/attach <image>', 'Attach image to the next prompt'],
       ['/attach clipboard', 'Attach image currently copied to macOS/Windows clipboard'],
       ['/attachments', 'List pending image attachments'],

package/src/ui/text-layout.mjs

@@ -19,11 +19,14 @@ import { strip as stripAnsi, width as visibleWidth } from './palette.mjs';
  *
  * @param {string} text
  * @param {number} maxWidth
+ * @param {{ preserveTrailingWhitespace?: boolean }} [options]
  * @returns {string[]}
  */
-export function wrapToLines(text, maxWidth) {
+export function wrapToLines(text, maxWidth, options = {}) {
   const width = Math.max(1, Math.floor(maxWidth));
   const source = String(text ?? '');
+  const preserveTrailingWhitespace = Boolean(options?.preserveTrailingWhitespace);
+  const finishLine = (line) => preserveTrailingWhitespace ? line : line.replace(/\s+$/, '');
   if (!source) return [''];
 
   const out = [];
@@ -38,8 +41,8 @@ export function wrapToLines(text, maxWidth) {
       const isSpace = /^\s+$/.test(stripAnsi(token));
       const candidate = current + token;
       if (visibleWidth(candidate) <= width) { current = candidate; continue; }
-      if (current) { out.push(current.replace(/\s+$/, '')); current = ''; }
-      if (isSpace) continue; // don't start a new line with pure whitespace
+      if (current) { out.push(finishLine(current)); current = ''; }
+      if (isSpace && !preserveTrailingWhitespace) continue; // don't start a new line with pure whitespace
       // Token alone still too wide — chunk it.
       if (visibleWidth(token) > width) {
         for (const chunk of chunkByVisibleWidth(token, width)) out.push(chunk);
@@ -47,7 +50,7 @@ export function wrapToLines(text, maxWidth) {
         current = token;
       }
     }
-    if (current) out.push(current.replace(/\s+$/, ''));
+    if (current) out.push(finishLine(current));
   }
   return out.length ? out : [''];
 }