tlc-claude-code 2.7.0 → 2.9.0

package/.claude/commands/tlc/audit.md

@@ -22,6 +22,18 @@ Run a comprehensive audit of the codebase against TLC coding standards.
 /tlc:audit
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'audit', prompt, project })`
+3. Report to user: "Dispatched audit to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

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

@@ -145,6 +145,18 @@ The existing autofix instructions below are the Inline Mode instructions and sho
 /tlc:autofix
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'autofix', prompt, project })`
+3. Report to user: "Dispatched autofix to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

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

@@ -117,7 +117,7 @@ Claude is the **project manager**. Claude reads the plan, breaks tasks into smal
 
 ### Step O1: Read the Plan
 
-Read `.planning/phases/{N}-PLAN.md`. Extract each task's goal, files, acceptance criteria, and test cases.
+Read `.planning/phases/{PHASE_ID}-PLAN.md`, falling back to legacy `.planning/phases/{N}-PLAN.md` when no prefixed file exists. Extract each task's goal, files, acceptance criteria, and test cases.
 
 ### Step O2: Check Orchestrator Health
 
@@ -158,6 +158,16 @@ fs.writeFileSync(path, JSON.stringify(existing, null, 2));
 "
 ```
 
+After dispatching, monitor each session to completion with `completion-checker` and react to the returned monitor state:
+
+- When a session completes, call `skill-dispatcher.captureResult()` to collect its output before merge-back
+- `stuck` -> ask the user: `Session stuck. Retry or cancel?`
+- `budget_exhausted` -> ask the user: `Budget exhausted. Re-dispatch or skip?`
+- `completed` -> proceed with merge-back
+- `crashed` / `errored` -> report the error, skip that task, and continue with remaining tasks
+
+Treat `completion-checker` as the source of truth for whether a session should merge, pause for user input, or be skipped.
+
 ### Step O3-fallback: Direct Dispatch (No Orchestrator)
 
 If orchestrator is down, dispatch directly via tmux on the host:
@@ -173,13 +183,15 @@ After dispatching all tasks, report:
 
 ```
 Dispatched N tasks to orchestrator:
-  ses_abc123  Task 1: Create schema         codex  running
-  ses_def456  Task 2: Add validation         codex  running
+  ses_abc123  Task 1: Create schema         codex  running  monitor=running
+  ses_def456  Task 2: Add validation        codex  running  monitor=running
 
 Run /tlc:status to check progress.
 I'm free — what would you like to work on?
 ```
 
+Include each session's current monitor state in the status display. When available, prefer the same session-status formatting used by orchestration status views so monitor values stay consistent across commands.
+
 **STOP HERE.** Do not write code. Do not execute inline mode. Claude is the PM, not the coder.
 
 ### Step O5: Monitor (When User Asks)
@@ -395,6 +407,20 @@ This is the core TLC command. Tests before code, one task at a time.
 /tlc:build <phase_number> --agents 5        # Limit parallel agents to 5
 ```
 
+## Phase Resolution
+
+Before loading plans, normalize the phase argument:
+
+1. If the argument is prefixed, such as `CORE-3`, discover the workspace manifest with `server/lib/workspace-manifest.js`, resolve the prefix to a repo, and run the build in that repo directory (for example `../tlc-core`).
+2. If the argument is unprefixed, such as `108`, resolve it to the current repo prefix when the workspace manifest exists, producing `TLC-108` in this repo.
+3. If the prefix is unknown, stop with:
+   `Unknown prefix FOO. Known: TLC, CORE, SA`
+4. If no workspace manifest exists:
+   - Prefixed cross-repo IDs return an error
+   - Unprefixed IDs still work in the current repo for backward compatibility
+
+Use `{PHASE_ID}` for artifact lookup and keep `{phase_number}` as the numeric/local branch component when needed.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
@@ -443,7 +469,12 @@ fi
 
 ### Step 1: Load Plans
 
-Read all `.planning/phases/{phase}-*-PLAN.md` files for this phase.
+Read the phase plan using prefixed matching first:
+
+- Preferred: `.planning/phases/{PREFIX}-{N}-PLAN.md`
+- Backward-compatible fallback: `.planning/phases/{N}-PLAN.md`
+
+Do not use the old ambiguous glob `.planning/phases/{phase}-*-PLAN.md` for primary lookup.
 
 ### Step 1a: Auto-Parallel Detection
 

package/.claude/commands/tlc/cleanup.md

@@ -25,7 +25,19 @@ Automatically fix all coding standards violations. No prompts - just fixes every
 /tlc:cleanup
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'cleanup', prompt, project })`
+3. Report to user: "Dispatched cleanup to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Inject Standards
 

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

@@ -138,6 +138,18 @@ The existing coverage instructions below are the Inline Mode instructions and sh
 - When joining a project to understand test gaps
 - After "vibe coding" a feature without tests
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'coverage', prompt, project })`
+3. Report to user: "Dispatched coverage to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

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

@@ -149,6 +149,18 @@ This command is not a blank-page brainstorming prompt. The agent should do the i
 
 If no phase number, auto-detect current phase from `.planning/ROADMAP.md`.
 
+## Background Dispatch (Research Only)
+
+When the orchestrator is available, dispatch Step 1 (Scan Context) to a background agent for fast research, then continue the interview inline with the results.
+
+1. Check orchestrator health
+2. If available: dispatch a research agent via `skill-dispatcher.dispatch({ skill: 'discuss-research', prompt: 'Scan the codebase for phase context: read ROADMAP, PROJECT.md, relevant code, recent changes. Return structured context as JSON.' })`
+3. When research agent completes, capture result and inject as context for Step 2 (Expand Before Asking)
+4. Steps 2+ (the actual interview) always run inline - they need user interaction
+5. If orchestrator unavailable, run Step 1 inline as before
+
+Override: `--inline` flag forces all steps inline.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

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

@@ -187,7 +187,19 @@ Once set up, GitHub Actions automatically:
 
 2. **You don't need to manually maintain docs.** Just push code.
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'docs', prompt, project })`
+3. Report to user: "Dispatched docs to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Run Setup (Once)
 

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

@@ -147,7 +147,19 @@ The existing edge-case generation instructions below are the Inline Mode instruc
 
 If no arguments, prompts for target.
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'edge-cases', prompt, project })`
+3. Report to user: "Dispatched edge-cases to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Identify Target
 

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

@@ -173,6 +173,32 @@ The existing planning instructions below are the Inline Mode instructions and sh
 
 If no phase number, auto-detect current phase from ROADMAP.md.
 
+## Phase Resolution
+
+Before reading or writing phase artifacts, normalize the requested phase argument:
+
+1. If the user passes a prefixed ID such as `CORE-3`, discover the workspace manifest via `server/lib/workspace-manifest.js` and resolve the target repo from the prefix.
+2. If the user passes an unprefixed ID such as `108`, resolve it to the current repo prefix when the workspace manifest is available, producing `TLC-108` in this repo.
+3. If the user passes an unknown prefix, stop with:
+   `Unknown prefix FOO. Known: TLC, CORE, SA`
+4. If no workspace manifest exists:
+   - Prefixed cross-repo IDs return an error because repo resolution is unavailable
+   - Unprefixed IDs still work in the current repo for backward compatibility
+
+When a prefixed ID resolves to another repo, operate in that repo's directory (for example `CORE-3` resolves via the manifest and runs against `../tlc-core`).
+
+## Background Dispatch (Research Only)
+
+When the orchestrator is available, dispatch research (architecture scan, existing patterns, stack analysis) to a background agent before creating the plan inline.
+
+1. Check orchestrator health
+2. If available: dispatch research agent via `skill-dispatcher.dispatch({ skill: 'plan-research', prompt: 'Scan project structure, existing patterns, tech stack, and recent changes. Return structured context for planning.' })`
+3. When research completes, inject results into Step 1 (Load Context)
+4. Steps 2+ (task breakdown, plan creation) always run inline - they need user review
+5. If orchestrator unavailable, run all steps inline as before
+
+Override: `--inline` flag forces all steps inline.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.
@@ -194,7 +220,7 @@ If CodeDB is unavailable, fall back to Grep/Glob/Read.
 
 Read:
 - `.planning/ROADMAP.md` - phase goal
-- `.planning/phases/{N}-DISCUSSION.md` - implementation preferences
+- `.planning/phases/{PHASE_ID}-DISCUSSION.md` - implementation preferences
 - `PROJECT.md` - tech stack, constraints
 
 ### Step 2: Research (if needed)
@@ -204,7 +230,7 @@ For phases requiring external knowledge:
 - Check best practices
 - Identify patterns
 
-Create `.planning/phases/{N}-RESEARCH.md` with findings.
+Create `.planning/phases/{PHASE_ID}-RESEARCH.md` with findings.
 
 ### Step 3: Break Into Tasks
 
@@ -270,10 +296,10 @@ Use `/tlc:claim` to claim a task, `/tlc:release` to release one.
 
 ### Step 4: Create Plan File
 
-Create `.planning/phases/{N}-PLAN.md`:
+Create `.planning/phases/{PHASE_ID}-PLAN.md` using the repo prefix when available, for example `TLC-{N}-PLAN.md`. If no workspace manifest or prefixed artifacts exist, fall back to legacy `{N}-PLAN.md`.
 
 ```markdown
-# Phase {N}: {Name} - Plan
+# Phase {PHASE_ID}: {Name} - Plan
 
 ## Overview
 
@@ -380,7 +406,7 @@ If the result is `true`:
      fs
    });
    console.log(JSON.stringify(r));
-   " ".planning/phases/{N}-PLAN.md" 2>/dev/null
+   " ".planning/phases/{PHASE_ID}-PLAN.md" 2>/dev/null
    ```
 2. Report results: "GitHub: Created N issues, updated M, linked to project board"
 3. If sync fails, warn but do not block: "GitHub sync failed: [reason]. Plan saved locally. Run `/tlc:issues sync` to retry."
@@ -413,7 +439,7 @@ Allow refinement if needed.
 ### Step 6: Save and Continue
 
 ```
-Plan saved to .planning/phases/{N}-PLAN.md
+Plan saved to .planning/phases/{PHASE_ID}-PLAN.md
 
 Ready to build?
 1) Yes, run /tlc:build (writes tests first)

package/.claude/commands/tlc/preflight.md

@@ -15,6 +15,18 @@ It also runs:
 - After any multi-file change
 - Before recommending a commit or push
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'preflight', prompt, project })`
+3. Report to user: "Dispatched preflight to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/progress.md

@@ -31,26 +31,40 @@ No project found.
 Run /tlc:new-project to start, or /tlc:init to add TLC to existing code.
 ```
 
-### Step 2: Parse Roadmap
+### Step 2: Detect Workspace Scope
 
-Read `.planning/ROADMAP.md` and identify:
+Try to discover a workspace manifest via `server/lib/workspace-manifest.js`.
+
+- If a manifest exists, switch to workspace-wide progress mode
+- Use the manifest `workspace` name in the header
+- Iterate all repos declared in the manifest, listing the current repo first
+- Repos whose paths do not exist on disk must be shown as `[not cloned]`
+- If no manifest exists, fall back to single-repo mode
+
+### Step 3: Parse Roadmap
+
+In single-repo mode, read `.planning/ROADMAP.md` and identify:
 - Total phases
 - Completed phases (marked `[x]` or `[completed]`)
 - Current phase (marked `[>]` or `[current]`)
 - Pending phases
 
-### Step 3: Check Current Phase State
+In workspace-wide mode, do the same per repo and produce a compact repo summary such as:
+
+`TLC: Phase TLC-108 (3/10) | CORE: Phase CORE-1b (idle) | SA: Phase SA-105f (complete)`
+
+### Step 4: Check Current Phase State
 
 For the current/next phase, check what exists:
 
 | File | Meaning |
 |------|---------|
-| `{N}-DISCUSSION.md` | Discussed |
-| `{N}-PLAN.md` | Planned |
-| `{N}-TESTS.md` | Tests written |
-| `{N}-VERIFIED.md` | Human verified |
+| `{PREFIX}-{N}-DISCUSSION.md` or `{N}-DISCUSSION.md` | Discussed |
+| `{PREFIX}-{N}-PLAN.md` or `{N}-PLAN.md` | Planned |
+| `{PREFIX}-{N}-TESTS.md` or `{N}-TESTS.md` | Tests written |
+| `{PREFIX}-{N}-VERIFIED.md` or `{N}-VERIFIED.md` | Human verified |
 
-### Step 4: Run Tests
+### Step 5: Run Tests
 
 Execute test suite and capture:
 - Total tests
@@ -58,7 +72,7 @@ Execute test suite and capture:
 - Failing
 - Skipped
 
-### Step 5: Present Status
+### Step 6: Present Status
 
 ```
 Project: My App
@@ -82,6 +96,18 @@ Tests: 47 total | 45 passing | 2 failing
 Suggested: /tlc:build 4
 ```
 
+When workspace-wide mode is active, prefer a compact workspace summary:
+
+```
+Workspace: tlc-platform
+
+TLC: Phase TLC-108 (3/10) | CORE: Phase CORE-1b (idle) | SA: Phase SA-105f (complete)
+
+[TLC] Tests: 142 total | [CORE] Tests: 38 total | [SA] Tests: 67 total
+
+Next: /tlc in the active repo, or /tlc:build TLC-108
+```
+
 ### Step 5b: Team Status (Multi-User)
 
 If task markers (`[>@user]`, `[x@user]`) exist in PLAN.md, show team activity:
@@ -99,17 +125,17 @@ Parse `[>@user]` and `[x@user]` markers from current phase PLAN.md to build this
 
 If no markers exist, skip this section (single-user mode).
 
-### Step 6: Suggest Next Action
+### Step 7: Suggest Next Action
 
 Based on state:
 
 | State | Suggestion |
 |-------|------------|
-| No discussion | `/tlc:discuss {N}` |
-| Discussed, no plan | `/tlc:plan {N}` |
-| Planned, no tests | `/tlc:build {N}` |
-| Tests failing | Fix failures, then `/tlc:build {N}` |
-| Tests passing, not verified | `/tlc:verify {N}` |
+| No discussion | `/tlc:discuss {PHASE_ID}` |
+| Discussed, no plan | `/tlc:plan {PHASE_ID}` |
+| Planned, no tests | `/tlc:build {PHASE_ID}` |
+| Tests failing | Fix failures, then `/tlc:build {PHASE_ID}` |
+| Tests passing, not verified | `/tlc:verify {PHASE_ID}` |
 | Verified | Move to next phase |
 | All phases done | `/tlc:complete` |
 

package/.claude/commands/tlc/refactor.md

@@ -17,6 +17,18 @@ Same fixes as `/tlc:cleanup` but:
 /tlc:refactor
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'refactor', prompt, project })`
+3. Report to user: "Dispatched refactor to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

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

@@ -18,7 +18,19 @@ Review a GitHub/GitLab pull request for TLC compliance.
 /tlc:review-pr              # Review current PR (if on PR branch)
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'review-pr', prompt, project })`
+3. Report to user: "Dispatched review-pr to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Fetch PR Information
 
@@ -72,16 +84,25 @@ Same checks as `/tlc:review`:
 *Automated review by [TLC](https://github.com/jurgencalleja/TLC)*
 ```
 
-### Step 5: Post Review
-
-```bash
-# Post as PR comment
-gh pr comment <number> --body "<review_markdown>"
-
-# Or submit as review
-gh pr review <number> --approve --body "<review_markdown>"
-gh pr review <number> --request-changes --body "<review_markdown>"
-```
+### Step 5: Post Review
+
+```bash
+# Submit approval review first
+if ! gh pr review <number> --approve --body "<review_markdown>" 2>/tmp/pr-review-err; then
+  if grep -q "Can not approve your own pull request" /tmp/pr-review-err; then
+    gh pr comment <number> --body "<review_markdown>"
+    echo "Posted as comment (self-owned PR — GitHub blocks self-approval)"
+  else
+    cat /tmp/pr-review-err
+  fi
+fi
+
+# Post as PR comment directly when comment-only mode is needed
+gh pr comment <number> --body "<review_markdown>"
+
+# Or request changes as a formal review
+gh pr review <number> --request-changes --body "<review_markdown>"
+```
 
 ## Example Output
 

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

@@ -174,6 +174,18 @@ TLC automatically uses ALL providers configured for the `review` capability in `
 /tlc:review --base dev   # Review vs different base branch
 ```
 
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'review', prompt, project })`
+3. Report to user: "Dispatched review to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
 ## CodeDB Acceleration
 
 When CodeDB is available (`.mcp.json` has a `codedb` server), use these tools in the scan/search steps below. If CodeDB is unavailable, fall back to Grep/Glob/Read.

package/.claude/commands/tlc/security.md

@@ -16,7 +16,19 @@ Run security audit on project dependencies and display vulnerabilities.
 /tlc:security
 ```
 
-## Process
+## Background Dispatch
+
+When the orchestrator is available (`curl -sf http://localhost:3100/health`), dispatch this command to a background agent session instead of running inline.
+
+1. Check orchestrator health
+2. If available: package the full skill prompt with project context (branch, changed files, current phase) and dispatch via `skill-dispatcher.dispatch({ skill: 'security', prompt, project })`
+3. Report to user: "Dispatched security to background session ses_XXXX. Results will appear when complete."
+4. When session completes, capture result via `skill-dispatcher.captureResult()` and display summary
+5. If orchestrator unavailable, fall back to inline execution (existing behavior below)
+
+Override: `--inline` flag forces inline execution even when orchestrator is available.
+
+## Process
 
 ### Step 1: Detect Package Manager
 

package/.claude/commands/tlc/status.md

@@ -12,9 +12,26 @@ If no phase specified, shows overall test status.
 
 ## Process
 
-1. **Detect test framework** (Vitest, Jest, pytest, etc.)
-2. **Run the test suite**
-3. **Report results** with next action
+1. **Detect workspace scope**
+   - Try `server/lib/workspace-manifest.js`
+   - If a workspace manifest exists, gather test status for every repo in the manifest with the current repo listed first
+   - Repos missing on disk show `[not cloned]`
+   - If no manifest exists, fall back to current-repo-only status
+2. **Detect test framework** (Vitest, Jest, pytest, etc.)
+3. **Run the test suite**
+4. **Check active background agent sessions**
+   - Read `.tlc/.active-sessions.json` when present
+   - Query live session state for each active background session
+   - Use the shared `session-status` display functions for formatting session rows
+   - Show each running background agent with: skill name, elapsed time, session ID, and monitor state
+   - Mark stuck or errored sessions with `[!]`
+5. **Report results** with next action
+
+When workspace mode is active, include a one-line summary such as:
+
+```text
+[TLC] 142 tests | [CORE] 38 tests | [SA] 67 tests
+```
 
 ## Output Examples
 
@@ -27,6 +44,28 @@ Test Status
 Ready for: /tlc:verify
 ```
 
+**Workspace-wide:**
+```
+Test Status
+───────────
+[TLC] 142 tests | [CORE] 38 tests | [SA] 67 tests
+
+Background Agents:
+  [TLC] review     ses_abc123  2m30s  running
+  [TLC] watchci    ses_def456  15m    running
+  [CORE] build     ses_ghi789  5m     stuck [!]
+
+Ready for: /tlc:verify in the active repo
+```
+
+When active background sessions exist, always include a `Background Agents:` section after the test summary. Prefer session-status formatting helpers so the output stays aligned with other orchestration views.
+
+Alerting rules:
+
+- Show `[!]` for `stuck` sessions
+- Show `[!]` for `errored` sessions
+- Include the monitor state verbatim (`running`, `stuck`, `budget_exhausted`, `crashed`, etc.)
+
 **Some failing:**
 ```
 Test Status