tlc-claude-code 2.4.0 → 2.4.2

package/.claude/commands/tlc/autofix.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'autofix', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"autofix\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/build.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'build', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"build\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/coverage.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'coverage', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"coverage\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/discuss.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'discuss', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"discuss\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/docs.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'docs', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"docs\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/edge-cases.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'edge-cases', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"edge-cases\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/plan.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'plan', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"plan\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/quick.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'quick', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"quick\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/.claude/commands/tlc/review.md

@@ -10,12 +10,76 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 1. Read routing config:
    ```bash
-   node -e "
-     const { resolveRouting } = require('./server/lib/task-router-config');
-     const flagModel = (process.argv.find(a => a.startsWith("--model")) || "").replace("--model=", "").replace("--model ", "") || null;
-     const r = resolveRouting({ command: 'review', flagModel, projectDir: process.cwd(), homeDir: process.env.HOME });
-     console.log(JSON.stringify(r));
-   " 2>/dev/null
+   node -e "const fs = require('fs');
+const path = require('path');
+const os = require('os');
+function readJson(filePath, fileSystem) {
+  try {
+    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function loadPersonalConfig(options) {
+  const configPath = path.join(options.homeDir, '.tlc', 'config.json');
+  return readJson(configPath, options.fs);
+}
+function loadProjectOverride(options) {
+  const configPath = path.join(options.projectDir, '.tlc.json');
+  const data = readJson(configPath, options.fs);
+  return data && data.task_routing_override ? data.task_routing_override : null;
+}
+function resolveRouting(options) {
+  let models = ['claude'];
+  let strategy = 'single';
+  let source = 'shipped-defaults';
+  let providers;
+  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });
+  if (personal) {
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+    const personalRouting = personal.task_routing && personal.task_routing[options.command];
+    if (personalRouting) {
+      if (Array.isArray(personalRouting.models)) {
+        models = personalRouting.models.slice();
+      } else if (typeof personalRouting.model === 'string') {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[options.command];
+    if (overrideEntry) {
+      if (Array.isArray(overrideEntry.models)) {
+        models = overrideEntry.models.slice();
+      } else if (typeof overrideEntry.model === 'string') {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+  if (options.flagModel) {
+    models = [options.flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+const result = resolveRouting({ command: \"review\", flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });
+process.stdout.write(JSON.stringify(result));" 2>/dev/null
    ```
 
 2. If `models[0]` is NOT `claude` (i.e., routed to external model):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",

package/server/lib/routing-preamble.js

@@ -0,0 +1,93 @@
+function escapeForDoubleQuotedShell(value) {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`');
+}
+
+function buildProgram(commandName) {
+  const serializedCommand = JSON.stringify(commandName);
+
+  return [
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "const os = require('os');",
+    "function readJson(filePath, fileSystem) {",
+    "  try {",
+    "    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));",
+    "  } catch {",
+    "    return null;",
+    "  }",
+    "}",
+    "function loadPersonalConfig(options) {",
+    "  const configPath = path.join(options.homeDir, '.tlc', 'config.json');",
+    "  return readJson(configPath, options.fs);",
+    "}",
+    "function loadProjectOverride(options) {",
+    "  const configPath = path.join(options.projectDir, '.tlc.json');",
+    "  const data = readJson(configPath, options.fs);",
+    "  return data && data.task_routing_override ? data.task_routing_override : null;",
+    "}",
+    "function resolveRouting(options) {",
+    "  let models = ['claude'];",
+    "  let strategy = 'single';",
+    "  let source = 'shipped-defaults';",
+    "  let providers;",
+    "  const personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });",
+    "  if (personal) {",
+    "    if (personal.model_providers) {",
+    "      providers = personal.model_providers;",
+    "    }",
+    "    const personalRouting = personal.task_routing && personal.task_routing[options.command];",
+    "    if (personalRouting) {",
+    "      if (Array.isArray(personalRouting.models)) {",
+    "        models = personalRouting.models.slice();",
+    "      } else if (typeof personalRouting.model === 'string') {",
+    "        models = [personalRouting.model];",
+    "      }",
+    "      if (personalRouting.strategy) {",
+    "        strategy = personalRouting.strategy;",
+    "      }",
+    "      source = 'personal-config';",
+    "    }",
+    "  }",
+    "  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });",
+    "  if (projectOverride) {",
+    "    const overrideEntry = projectOverride[options.command];",
+    "    if (overrideEntry) {",
+    "      if (Array.isArray(overrideEntry.models)) {",
+    "        models = overrideEntry.models.slice();",
+    "      } else if (typeof overrideEntry.model === 'string') {",
+    "        models = [overrideEntry.model];",
+    "      }",
+    "      if (overrideEntry.strategy) {",
+    "        strategy = overrideEntry.strategy;",
+    "      }",
+    "      source = 'project-override';",
+    "    }",
+    "  }",
+    "  if (options.flagModel) {",
+    "    models = [options.flagModel];",
+    "    strategy = 'single';",
+    "    source = 'flag-override';",
+    "  }",
+    "  const result = { models, strategy, source };",
+    "  if (providers) {",
+    "    result.providers = providers;",
+    "  }",
+    "  return result;",
+    "}",
+    `const result = resolveRouting({ command: ${serializedCommand}, flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });`,
+    'process.stdout.write(JSON.stringify(result));',
+  ].join('\n');
+}
+
+function generatePreamble(commandName) {
+  const program = buildProgram(commandName);
+  return `node -e "${escapeForDoubleQuotedShell(program)}"`;
+}
+
+module.exports = {
+  generatePreamble,
+};

package/server/lib/routing-preamble.test.js

@@ -0,0 +1,255 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import routingPreamble from './routing-preamble.js';
+
+const { generatePreamble } = routingPreamble;
+
+function makeTempDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function runGeneratedScript({ commandName, homeConfig, projectConfig, cwdName = 'routing-project-', flagModel } = {}) {
+  const homeDir = makeTempDir('routing-home-');
+  const cwd = makeTempDir(cwdName);
+
+  if (homeConfig !== undefined) {
+    writeJson(path.join(homeDir, '.tlc', 'config.json'), homeConfig);
+  }
+
+  if (projectConfig !== undefined) {
+    writeJson(path.join(cwd, '.tlc.json'), projectConfig);
+  }
+
+  const script = generatePreamble(commandName);
+  const argv = ['-lc', flagModel ? `${script} -- ${JSON.stringify(flagModel)}` : script];
+  const output = execFileSync('bash', argv, {
+    cwd,
+    env: {
+      ...process.env,
+      HOME: homeDir,
+    },
+    encoding: 'utf8',
+  });
+
+  return JSON.parse(output);
+}
+
+describe('routing-preamble', () => {
+  it('returns shipped defaults when no config files exist', () => {
+    const result = runGeneratedScript({ commandName: 'build' });
+
+    expect(result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+    });
+  });
+
+  it('reads personal routing from ~/.tlc/config.json', () => {
+    const result = runGeneratedScript({
+      commandName: 'review',
+      homeConfig: {
+        task_routing: {
+          review: { models: ['codex', 'claude'], strategy: 'parallel' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['codex', 'claude'],
+      strategy: 'parallel',
+      source: 'personal-config',
+    });
+  });
+
+  it('reads project overrides from .tlc.json', () => {
+    const result = runGeneratedScript({
+      commandName: 'build',
+      homeConfig: {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'parallel' },
+        },
+      },
+      projectConfig: {
+        task_routing_override: {
+          build: { models: ['gemini'], strategy: 'single' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['gemini'],
+      strategy: 'single',
+      source: 'project-override',
+    });
+  });
+
+  it('accepts singular model in personal config and normalizes it to models', () => {
+    const result = runGeneratedScript({
+      commandName: 'build',
+      homeConfig: {
+        task_routing: {
+          build: { model: 'codex', strategy: 'single' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'personal-config',
+    });
+  });
+
+  it('prefers models over model in the same entry', () => {
+    const result = runGeneratedScript({
+      commandName: 'build',
+      homeConfig: {
+        task_routing: {
+          build: { model: 'gemini', models: ['codex', 'claude'], strategy: 'parallel' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['codex', 'claude'],
+      strategy: 'parallel',
+      source: 'personal-config',
+    });
+  });
+
+  it('includes model_providers from personal config', () => {
+    const providers = {
+      claude: { type: 'cli', command: 'claude' },
+      codex: { type: 'cli', command: 'codex' },
+    };
+
+    const result = runGeneratedScript({
+      commandName: 'build',
+      homeConfig: {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+        model_providers: providers,
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'personal-config',
+      providers,
+    });
+  });
+
+  it('lets a flag override win over project and personal config', () => {
+    const result = runGeneratedScript({
+      commandName: 'build',
+      flagModel: 'local-model',
+      homeConfig: {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'parallel' },
+        },
+      },
+      projectConfig: {
+        task_routing_override: {
+          build: { models: ['gemini'], strategy: 'parallel' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      models: ['local-model'],
+      strategy: 'single',
+      source: 'flag-override',
+    });
+  });
+
+  it('handles malformed personal config gracefully', () => {
+    const homeDir = makeTempDir('routing-home-');
+    const cwd = makeTempDir('routing-project-');
+    fs.mkdirSync(path.join(homeDir, '.tlc'), { recursive: true });
+    fs.writeFileSync(path.join(homeDir, '.tlc', 'config.json'), '{{not-json');
+
+    const output = execFileSync('bash', ['-lc', generatePreamble('build')], {
+      cwd,
+      env: {
+        ...process.env,
+        HOME: homeDir,
+      },
+      encoding: 'utf8',
+    });
+
+    expect(JSON.parse(output)).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+    });
+  });
+
+  it('handles malformed project config gracefully', () => {
+    const homeDir = makeTempDir('routing-home-');
+    const cwd = makeTempDir('routing-project-');
+    fs.writeFileSync(path.join(cwd, '.tlc.json'), '{broken');
+
+    const output = execFileSync('bash', ['-lc', generatePreamble('build')], {
+      cwd,
+      env: {
+        ...process.env,
+        HOME: homeDir,
+      },
+      encoding: 'utf8',
+    });
+
+    expect(JSON.parse(output)).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+    });
+  });
+
+  it('works in any directory and only consults the runtime cwd', () => {
+    const repoLikeDir = makeTempDir('routing-outside-');
+    const unrelatedDir = path.join(repoLikeDir, 'nested', 'workspace');
+    fs.mkdirSync(unrelatedDir, { recursive: true });
+    writeJson(path.join(unrelatedDir, '.tlc.json'), {
+      task_routing_override: {
+        docs: { model: 'codex', strategy: 'single' },
+      },
+    });
+
+    const homeDir = makeTempDir('routing-home-');
+    const output = execFileSync('bash', ['-lc', generatePreamble('docs')], {
+      cwd: unrelatedDir,
+      env: {
+        ...process.env,
+        HOME: homeDir,
+      },
+      encoding: 'utf8',
+    });
+
+    expect(JSON.parse(output)).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'project-override',
+    });
+  });
+
+  it('uses the generic default for unknown commands', () => {
+    const result = runGeneratedScript({ commandName: 'custom-command' });
+
+    expect(result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+    });
+  });
+});

package/server/lib/task-router-config.js

@@ -96,6 +96,8 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
     if (personalRouting) {
       if (personalRouting.models) {
         models = [...personalRouting.models];
+      } else if (personalRouting.model) {
+        models = [personalRouting.model];
       }
       if (personalRouting.strategy) {
         strategy = personalRouting.strategy;
@@ -111,6 +113,8 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
     if (overrideEntry) {
       if (overrideEntry.models) {
         models = [...overrideEntry.models];
+      } else if (overrideEntry.model) {
+        models = [overrideEntry.model];
       }
       if (overrideEntry.strategy) {
         strategy = overrideEntry.strategy;

package/server/lib/task-router-config.test.js

@@ -412,6 +412,71 @@ describe('task-router-config', () => {
       expect(result.providers).toEqual(personalConfig.model_providers);
     });
 
+    it('personal config with singular model (string) is normalized to models array', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { model: 'codex', strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.models).toEqual(['codex']);
+      expect(result.strategy).toBe('single');
+      expect(result.source).toBe('personal-config');
+    });
+
+    it('project override with singular model (string) is normalized to models array', () => {
+      const tlcJson = {
+        task_routing_override: {
+          review: { model: 'gemini', strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/project/.tlc.json': JSON.stringify(tlcJson),
+      });
+
+      const result = resolveRouting({
+        command: 'review',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.models).toEqual(['gemini']);
+      expect(result.strategy).toBe('single');
+      expect(result.source).toBe('project-override');
+    });
+
+    it('models array takes precedence over model string in same config entry', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { model: 'gemini', models: ['codex', 'claude'], strategy: 'parallel' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.models).toEqual(['codex', 'claude']);
+      expect(result.strategy).toBe('parallel');
+    });
+
     it('returns no providers when personal config has none', () => {
       const fs = mockFs({});