tlc-claude-code 2.4.1 → 2.4.3

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):
@@ -35,7 +99,13 @@ This command supports multi-model routing via `~/.tlc/config.json`.
 
 ## What This Does
 
-Gathers your preferences for HOW a phase should be built through adaptive questioning. Saves decisions to guide planning and test writing.
+Runs a short implementation interview for the current phase using a silent expansion workflow:
+- First scan the phase goal, codebase patterns, stack, and recent changes
+- Then propose a concrete implementation approach before asking questions
+- Ask only questions that materially improve the plan
+- Save decisions, trade-offs, and constraints to `.planning/phases/{N}-DISCUSSION.md`
+
+This command is not a blank-page brainstorming prompt. The agent should do the initial thinking first, then ask the user to confirm or correct the proposal.
 
 ## Usage
 
@@ -43,174 +113,219 @@ Gathers your preferences for HOW a phase should be built through adaptive questi
 /tlc:discuss [phase_number]
 ```
 
-If no phase number, auto-detect current phase from ROADMAP.md.
+If no phase number, auto-detect current phase from `.planning/ROADMAP.md`.
 
 ## Process
 
-### Step 1: Load Phase Context
+### Step 1: Scan Context First
 
-Read from `.planning/ROADMAP.md` to get:
-- Phase name and goal
-- What comes before (context)
-- What comes after (constraints)
+Before asking anything, silently inspect the implementation context for the phase.
 
-### Step 2: Adaptive Questioning
+Read:
+- `.planning/ROADMAP.md` - current phase name, goal, and surrounding phase context
+- `PROJECT.md` - product constraints, stack, architecture, conventions
+- `.planning/phases/{N}-DISCUSSION.md` if it exists - previously made decisions and unresolved gaps
+- Relevant code for the phase area - existing modules, patterns, folder structure, interfaces, tests
 
-Ask about implementation preferences. Adapt questions based on phase type.
+Also inspect:
+- Tech stack already in use
+- Existing implementation patterns that should be preserved
+- Recent git changes that affect the phase direction, integration surface, or constraints
 
-**For UI/Frontend phases:**
-```
-Layout approach?
-1) Component library (shadcn, MUI, etc.)
-2) Custom components
-3) Minimal styling (Tailwind only)
-
-State management?
-1) React state + context
-2) Zustand / Jotai
-3) Redux
-4) Server state only (React Query)
-
-Form handling?
-1) React Hook Form
-2) Formik
-3) Native forms
-```
+The scan should answer:
+- What is this phase trying to accomplish?
+- What implementation shape is most consistent with the current codebase?
+- What decisions are already implied by the stack or recent work?
+- What is still genuinely ambiguous?
 
-**For API/Backend phases:**
-```
-API style?
-1) REST
-2) tRPC
-3) GraphQL
-
-Validation approach?
-1) Zod schemas
-2) Yup
-3) Manual validation
-
-Error handling?
-1) Return error objects
-2) Throw exceptions
-3) Result types (Ok/Err)
-```
+Do not ask the user to restate information that can be learned from the repo.
 
-**For Data/Database phases:**
-```
-Query approach?
-1) Raw SQL
-2) Query builder (Kysely, Knex)
-3) ORM (Prisma, Drizzle)
-
-Migration strategy?
-1) Schema-first (Prisma migrate)
-2) Code-first
-3) Manual SQL migrations
-```
+### Step 2: Expand Before Asking
 
-**For Auth phases:**
-```
-Auth provider?
-1) Custom (JWT + bcrypt)
-2) NextAuth / Auth.js
-3) Clerk / Auth0 / Supabase Auth
-
-Session storage?
-1) JWT in httpOnly cookie
-2) Database sessions
-3) Redis sessions
-```
+After scanning, propose a full default implementation approach before any questions.
 
-### Step 3: Capture Edge Cases
+The proposal should be concrete enough that the user can react to it:
+- Architecture and boundaries
+- Main components/modules/files involved
+- Data flow or request flow
+- Key trade-offs
+- Constraints or risks that seem likely
+- Assumptions inferred from the stack and recent code
 
-```
-What edge cases should we handle?
+The proposal should sound like:
+
+```text
+Based on the roadmap goal, current patterns, and recent changes, I would implement this as:
+- ...
+- ...
 
-- Empty states?
-- Error states?
-- Loading states?
-- Offline behavior?
-- Rate limiting?
+The main open decisions I still need to confirm are:
+1. ...
+2. ...
 ```
 
-### Step 4: Capture Constraints
+Do not ask "What do you want?" or "How should we build this?" before giving a recommendation.
 
-```
-Any constraints or requirements?
+### Step 3: Filter Questions Aggressively
+
+Only ask a question if removing it would degrade the resulting `DISCUSSION.md` or weaken the next `/tlc:plan`.
+
+Each question must extract substance such as:
+- Architectural decisions
+- Integration boundaries
+- Operational constraints
+- Failure-mode handling
+- Trade-offs that materially change implementation
+
+Do not ask about preferences that do not affect the outcome, such as:
+- Naming choices
+- Formatting
+- Minor stylistic conventions
+- Options already dictated by the existing stack unless there is a real conflict
+
+Bad:
+- "What database should we use?"
+- "How do you want this named?"
+
+Good:
+- "I would keep this on SQLite with WAL mode because the project already uses local-first storage and recent work assumes file-backed state. Any reason to use a different persistence strategy?"
+- "I would model this as a service plus thin CLI adapter to match the existing command architecture. Good, or do you need a different boundary for reuse/testing?"
 
-- Performance targets?
-- Accessibility requirements?
-- Browser support?
-- Mobile considerations?
+### Step 4: Ask Propose-Then-Confirm Questions
+
+Every question must include:
+- The recommended answer
+- The evidence behind that recommendation
+- The decision to confirm or correct
+
+Question style:
+
+```text
+1. Persistence
+I would use SQLite with WAL mode because the current stack is local-first and this phase needs durable state with low operational overhead.
+Good to keep that, or do you need a different storage model for sync/concurrency reasons?
 ```
 
-### Step 5: Save Discussion
+Prefer questions that let the user confirm, reject, or constrain the recommendation.
+
+### Step 5: Calibrate Depth
+
+Choose question count based on phase complexity.
 
-Create `.planning/phases/{N}-DISCUSSION.md`:
+For simple phases:
+- Ask 2-3 questions maximum
+- Focus on the few decisions that materially change scope or architecture
+
+For complex phases:
+- Ask 5-8 questions
+- Cover the major decision surfaces only
+
+Complexity signals include:
+- Multiple subsystems or services
+- New infrastructure or persistence
+- Cross-cutting auth/security concerns
+- Large UX flows with state transitions
+- Significant ambiguity in roadmap wording
+
+Do not turn straightforward phases into long interviews.
+
+### Step 6: Iterate When Answers Reveal New Gaps
+
+If the user’s answers expose a new implementation gap, contradiction, or constraint, ask targeted follow-up questions.
+
+Follow-up questions must also use the same pattern:
+- explain the inferred implication
+- recommend the likely answer
+- ask for confirmation/correction
+
+Stop when the remaining uncertainty no longer meaningfully affects planning.
+
+### Step 7: Write Concrete Decisions
+
+Create or update `.planning/phases/{N}-DISCUSSION.md`.
+
+The file must contain decisions and rationale, not a transcript of the conversation.
+
+Use this structure:
 
 ```markdown
 # Phase {N}: {Name} - Discussion
 
-## Implementation Preferences
+## Proposed Approach
 
-| Decision | Choice | Notes |
-|----------|--------|-------|
-| State management | Zustand | Simple, minimal boilerplate |
-| Form handling | React Hook Form | Good validation support |
-| API style | tRPC | Type-safe, good DX |
+[Short summary of the implementation direction that emerged from the scan and discussion]
 
-## Edge Cases to Handle
+## Decisions
 
-- [ ] Empty state when no data
-- [ ] Error toast on API failure
-- [ ] Optimistic updates for better UX
+| Decision | Recommendation | Confirmed / Adjusted | Why It Matters |
+|----------|----------------|----------------------|----------------|
+| Service boundary | Core service with thin CLI adapter | Confirmed | Matches existing command architecture and keeps logic testable |
+| Persistence | SQLite with WAL mode | Adjusted: in-memory for this phase | Avoids premature persistence until sync arrives |
 
 ## Constraints
 
-- Must work on mobile
-- Target 100ms API response time
+- Must preserve existing module boundaries
+- Must work with current local-first workflow
+- Must remain compatible with `/tlc:plan`
 
-## Notes
+## Risks / Follow-Ups
 
-[Any additional context from discussion]
-```
+- Migration path needed if persistence changes in later phases
+- Error handling contract should be validated in planning
 
-### Step 6: Confirm and Continue
+## Planning Notes
 
+- Call out concrete file/module areas likely to change
+- Record unresolved items only if they materially affect planning
 ```
-Discussion saved to .planning/phases/{N}-DISCUSSION.md
 
-Ready to plan this phase?
-1) Yes, continue to /tlc:plan
-2) No, I'll plan later
-```
+Guidelines for the output:
+- Prefer concrete decisions over raw notes
+- Capture trade-offs and rationale briefly
+- Record unresolved questions only if they still matter for `/tlc:plan`
+- Do not dump the full interview transcript
 
-## Example
+### Step 8: Confirm Next Step
+
+After writing the file, report:
+
+```text
+Discussion saved to .planning/phases/{N}-DISCUSSION.md
 
+Ready to continue with /tlc:plan?
+1) Yes
+2) No
 ```
-> /tlc:discuss 2
 
-Phase 2: User Dashboard
+## Interview Rules
 
-Let's discuss how to build this.
+- Scan before asking
+- Propose before questioning
+- Ask only high-leverage questions
+- Recommend an answer in every question
+- Prefer substance over preference
+- Adapt question count to phase complexity
+- Add follow-ups only when answers reveal real new gaps
+- Produce a decision document, not a transcript
 
-State management approach?
-1) React state + context
-2) Zustand
-3) Server state only (React Query)
+## Example Opening
 
-> 3
+```text
+> /tlc:discuss 2
+
+Phase 2: User Dashboard
 
-Data fetching?
-1) REST + fetch
-2) tRPC
-3) React Query + REST
+Based on the roadmap goal, the existing React + tRPC patterns, and recent changes in the dashboard data layer, I would implement this as a server-driven dashboard shell with a thin client state layer for filters and optimistic updates.
 
-> 2
+I would keep data fetching in the existing query pattern, add one aggregation endpoint for summary cards, and keep widget rendering as local components rather than introducing a new layout system.
 
-[...continues until preferences captured...]
+The main decisions I still need to confirm are:
 
-Discussion saved.
+1. Dashboard state boundary
+I would keep filter/sort state in URL params plus local component state so it stays shareable without introducing a global store.
+Good, or do you need cross-page state that justifies Zustand?
 
-Ready to plan? (Y/n)
+2. Empty/loading/error behavior
+I would standardize on skeleton loading plus inline empty states because that matches current UI behavior and keeps failure modes visible per widget.
+Good, or do you need a page-level loading/error shell?
 ```

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/e2e-verify.md

@@ -78,7 +78,7 @@ await page.screenshot({ path: '/tmp/tlc-screenshots/login.png', fullPage: true }
 
 // After login
 await page.fill('[data-testid="email"]', 'user@local.com');
-await page.fill('[data-testid="password"]', '2026rocks');
+await page.fill('[data-testid="password"]', 'REDACTED');
 await page.click('[data-testid="login-btn"]');
 await page.waitForURL('**/dashboard**');
 await page.screenshot({ path: '/tmp/tlc-screenshots/after-login.png', fullPage: true });

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):