@towles/tool 0.0.106 → 0.0.108

package/plugins/tt-agentboard/packages/runtime/test/config.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig, saveConfig } from "../src/config";
+
+const TEST_HOME = join(import.meta.dir, ".test-home");
+const CONFIG_DIR = join(TEST_HOME, ".config", "towles-tool", "agentboard");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+describe("config", () => {
+  beforeEach(() => {
+    rmSync(TEST_HOME, { recursive: true, force: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_HOME, { recursive: true, force: true });
+  });
+
+  describe("loadConfig", () => {
+    it("returns defaults when no config file exists", () => {
+      const config = loadConfig(TEST_HOME);
+      expect(config.plugins).toEqual([]);
+      expect(config.port).toBeUndefined();
+      expect(config.theme).toBeUndefined();
+      expect(config.sidebarWidth).toBeUndefined();
+    });
+
+    it("reads config from disk", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(
+        CONFIG_FILE,
+        JSON.stringify({
+          port: 4201,
+          theme: "tokyo-night",
+          sidebarWidth: 30,
+          plugins: ["my-plugin"],
+        }),
+      );
+
+      const config = loadConfig(TEST_HOME);
+      expect(config.port).toBe(4201);
+      expect(config.theme).toBe("tokyo-night");
+      expect(config.sidebarWidth).toBe(30);
+      expect(config.plugins).toEqual(["my-plugin"]);
+    });
+
+    it("handles malformed JSON gracefully", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(CONFIG_FILE, "not json {{{");
+
+      const config = loadConfig(TEST_HOME);
+      expect(config.plugins).toEqual([]);
+    });
+  });
+
+  describe("saveConfig", () => {
+    it("creates config directory and file", () => {
+      saveConfig({ theme: "gruvbox-dark" }, TEST_HOME);
+
+      expect(existsSync(CONFIG_FILE)).toBe(true);
+      const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      expect(saved.theme).toBe("gruvbox-dark");
+    });
+
+    it("merges with existing config", () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(
+        CONFIG_FILE,
+        JSON.stringify({
+          theme: "nord",
+          sidebarWidth: 28,
+          plugins: [],
+        }),
+      );
+
+      saveConfig({ sidebarWidth: 32 }, TEST_HOME);
+
+      const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      expect(saved.theme).toBe("nord");
+      expect(saved.sidebarWidth).toBe(32);
+    });
+  });
+});

package/plugins/tt-agentboard/packages/runtime/test/tracker.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { AgentTracker, instanceKey } from "../src/agents/tracker";
+import type { AgentEvent } from "../src/contracts/agent";
+
+function makeEvent(overrides: Partial<AgentEvent> = {}): AgentEvent {
+  return {
+    agent: "claude-code",
+    session: "main",
+    status: "running",
+    ts: Date.now(),
+    ...overrides,
+  };
+}
+
+describe("instanceKey", () => {
+  it("returns agent name when no threadId", () => {
+    expect(instanceKey("claude-code")).toBe("claude-code");
+  });
+
+  it("returns agent:threadId when threadId provided", () => {
+    expect(instanceKey("claude-code", "abc123")).toBe("claude-code:abc123");
+  });
+});
+
+describe("AgentTracker", () => {
+  let tracker: AgentTracker;
+
+  beforeEach(() => {
+    tracker = new AgentTracker();
+  });
+
+  describe("applyEvent / getState", () => {
+    it("returns null for unknown session", () => {
+      expect(tracker.getState("unknown")).toBeNull();
+    });
+
+    it("tracks a single agent event", () => {
+      const event = makeEvent({ status: "running" });
+      tracker.applyEvent(event);
+
+      const state = tracker.getState("main");
+      expect(state).not.toBeNull();
+      expect(state!.status).toBe("running");
+      expect(state!.agent).toBe("claude-code");
+    });
+
+    it("returns highest priority agent", () => {
+      tracker.applyEvent(makeEvent({ agent: "amp", status: "idle" }));
+      tracker.applyEvent(makeEvent({ agent: "claude-code", status: "running" }));
+
+      const state = tracker.getState("main");
+      expect(state!.status).toBe("running");
+    });
+  });
+
+  describe("getAgents", () => {
+    it("returns empty array for unknown session", () => {
+      expect(tracker.getAgents("unknown")).toEqual([]);
+    });
+
+    it("returns all agents for a session sorted by ts desc", () => {
+      tracker.applyEvent(makeEvent({ agent: "amp", ts: 100 }));
+      tracker.applyEvent(makeEvent({ agent: "claude-code", ts: 200 }));
+
+      const agents = tracker.getAgents("main");
+      expect(agents).toHaveLength(2);
+      expect(agents[0]!.agent).toBe("claude-code");
+      expect(agents[1]!.agent).toBe("amp");
+    });
+  });
+
+  describe("getEventTimestamps", () => {
+    it("tracks event timestamps per session", () => {
+      tracker.applyEvent(makeEvent({ ts: 100 }));
+      tracker.applyEvent(makeEvent({ ts: 200 }));
+
+      const timestamps = tracker.getEventTimestamps("main");
+      expect(timestamps).toEqual([100, 200]);
+    });
+
+    it("caps at 30 timestamps", () => {
+      for (let i = 0; i < 40; i++) {
+        tracker.applyEvent(makeEvent({ ts: i }));
+      }
+      const timestamps = tracker.getEventTimestamps("main");
+      expect(timestamps).toHaveLength(30);
+      expect(timestamps[0]).toBe(10);
+    });
+  });
+
+  describe("unseen tracking", () => {
+    it("marks terminal status as unseen when session not active", () => {
+      tracker.applyEvent(makeEvent({ status: "done" }));
+      expect(tracker.isUnseen("main")).toBe(true);
+    });
+
+    it("marks seen on focus", () => {
+      tracker.applyEvent(makeEvent({ status: "done" }));
+      tracker.handleFocus("main");
+      expect(tracker.isUnseen("main")).toBe(false);
+    });
+
+    it("markSeen clears unseen flags", () => {
+      tracker.applyEvent(makeEvent({ status: "error" }));
+      expect(tracker.markSeen("main")).toBe(true);
+      expect(tracker.isUnseen("main")).toBe(false);
+    });
+  });
+
+  describe("dismiss", () => {
+    it("removes an agent instance", () => {
+      tracker.applyEvent(makeEvent({ agent: "claude-code" }));
+      const removed = tracker.dismiss("main", "claude-code");
+      expect(removed).toBe(true);
+      expect(tracker.getState("main")).toBeNull();
+    });
+
+    it("returns false for non-existent agent", () => {
+      expect(tracker.dismiss("main", "nonexistent")).toBe(false);
+    });
+  });
+
+  describe("pruneStuck", () => {
+    it("prunes running agents older than timeout", () => {
+      tracker.applyEvent(makeEvent({ status: "running", ts: Date.now() - 10_000 }));
+      tracker.pruneStuck(5_000);
+      expect(tracker.getState("main")).toBeNull();
+    });
+
+    it("does not prune pinned agents", () => {
+      tracker.applyEvent(makeEvent({ status: "running", ts: Date.now() - 10_000 }));
+      tracker.setPinnedInstances("main", ["claude-code"]);
+      tracker.pruneStuck(5_000);
+      expect(tracker.getState("main")).not.toBeNull();
+    });
+  });
+
+  describe("pruneTerminal", () => {
+    it("prunes seen terminal agents after timeout", () => {
+      const event = makeEvent({ status: "done", ts: Date.now() - 6 * 60 * 1000 });
+      tracker.applyEvent(event);
+      tracker.markSeen("main");
+      tracker.pruneTerminal();
+      expect(tracker.getState("main")).toBeNull();
+    });
+
+    it("does not prune unseen terminal agents", () => {
+      tracker.applyEvent(makeEvent({ status: "done", ts: Date.now() - 6 * 60 * 1000 }));
+      // Don't mark seen
+      tracker.pruneTerminal();
+      expect(tracker.getState("main")).not.toBeNull();
+    });
+  });
+
+  describe("multi-thread support", () => {
+    it("tracks multiple threads for the same agent", () => {
+      tracker.applyEvent(makeEvent({ threadId: "t1", status: "running" }));
+      tracker.applyEvent(makeEvent({ threadId: "t2", status: "done" }));
+
+      const agents = tracker.getAgents("main");
+      expect(agents).toHaveLength(2);
+    });
+
+    it("getState returns highest priority across threads", () => {
+      tracker.applyEvent(makeEvent({ threadId: "t1", status: "done" }));
+      tracker.applyEvent(makeEvent({ threadId: "t2", status: "running" }));
+
+      const state = tracker.getState("main");
+      expect(state!.status).toBe("running");
+    });
+  });
+});

package/plugins/tt-agentboard/packages/runtime/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "test/**/*"]
+}

package/plugins/tt-agentboard/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "types": ["@types/bun"]
+  },
+  "include": ["apps/**/*.ts", "apps/**/*.tsx", "packages/**/*.ts"]
+}

package/plugins/tt-auto-claude/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "tt-ac",
+  "description": "Auto-Claude pipeline: automated issue-to-PR workflows using Claude Code",
+  "version": "0.0.108",
+  "author": {
+    "name": "Chris Towles"
+  }
+}

package/plugins/tt-auto-claude/commands/create-issue.md

@@ -0,0 +1,20 @@
+---
+description: Create a GitHub issue with the auto-claude label for AI-driven work
+allowed-tools: Bash(gh *), AskUserQuestion(*)
+---
+
+Create a GitHub issue with the `auto-claude` label for Claude Code pipeline work.
+
+1. Get repo: `gh repo view --json nameWithOwner --jq '.nameWithOwner'`
+2. Fetch labels: `gh label list --repo <repo> --json name --jq '.[].name'`
+3. AskUserQuestion (up to 4 at once): title, description, extra labels (multi-select from repo labels)
+4. `gh issue create`:
+   - Always include `auto-claude` label + any extras
+   - Prefix title with conventional type (`feat:`, `fix:`, `refactor:`, `research:`, `chore:`)
+   - Body: `## Summary`, `## Type`, `## Notes` sections
+   - If `auto-claude` label missing, create it first:
+     `gh label create "auto-claude" --repo <repo> --description "Issue for Claude Code auto-claude pipeline" --color "7C3AED"`
+5. **Batch**: multiple issues → create in parallel with appropriate prefix/labels each
+6. Report all issue URLs in a table
+
+$ARGUMENTS

package/plugins/tt-auto-claude/commands/list.md

@@ -0,0 +1,21 @@
+---
+description: List open issues with the auto-claude label in the current repo
+allowed-tools: Bash(gh *)
+---
+
+List open issues across all auto-claude pipeline states in the current repo.
+
+1. Get repo: `gh repo view --json nameWithOwner --jq '.nameWithOwner'`
+2. `gh issue list --repo <repo> --state open --json number,title,labels,assignees,state --limit 50` for each label:
+   - `auto-claude` (queued)
+   - `auto-claude-in-progress`
+   - `auto-claude-failed`
+   - `auto-claude-review`
+3. Deduplicate across queries. Display as a table sorted by issue number:
+
+   | #   | Title | Status | Labels | Assignee |
+   | --- | ----- | ------ | ------ | -------- |
+
+   Status derived from pipeline label. Labels column excludes pipeline labels. Assignee shows login or `—`.
+
+$ARGUMENTS

package/plugins/tt-auto-claude/skills/auto-claude/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: auto-claude
+description: Use the auto-claude pipeline (`tt auto-claude` / `tt ac`) for automated issue-to-PR workflows — labels a GitHub issue, then runs plan → implement → simplify → review autonomously.
+---
+
+# Auto-Claude Pipeline
+
+Automated issue-to-PR pipeline. Label a GitHub issue with `auto-claude` and the pipeline runs Claude Code locally through 4 steps: **plan → implement → simplify → review**.
+
+## Pipeline Steps
+
+1. **Plan** — Research, planning, and annotations. Produces `plan.md`.
+2. **Implement** — Executes the plan: writes code, tests, commits. Produces `completed-summary.md`.
+3. **Simplify** — Code-simplify pass: removes dead code, simplifies logic. Produces `simplify-summary.md`.
+4. **Review** — Automated review outputs `PASS` or `FAIL` on first line of `review.md`.
+
+## Label Flow
+
+1. Issue labelled `auto-claude` triggers the pipeline.
+2. Pipeline removes `auto-claude`, adds `auto-claude-in-progress`.
+3. On success: removes `auto-claude-in-progress`, adds `auto-claude-review`, creates PR.
+4. On failure: removes `auto-claude-in-progress`, adds `auto-claude-failed`.
+
+## Retry Behavior
+
+If review outputs FAIL, the pipeline loops back to **implement → simplify → review** (clearing previous artifacts). Configurable via `maxReviewRetries` (default 2), so up to 3 total attempts.
+
+## CLI Commands
+
+```bash
+# Process specific issue
+tt auto-claude --issue 42
+tt ac --issue 42
+
+# Stop after planning step (review before implementation)
+tt ac --issue 42 --until plan
+
+# Rebase stale PR branch onto current main
+tt ac --refresh --issue 42
+
+# Reset state for an issue (force restart)
+tt ac --reset 42
+
+# Start polling loop (default 30min interval)
+tt ac --loop
+
+# Custom interval and limit
+tt ac --loop --interval 15 --limit 3
+
+# Interactively pick an auto-claude issue to process
+tt ac list
+```
+
+## Config
+
+Auto-detects repo and main branch from cwd. Key settings:
+
+| Field                    | Default       | Description                         |
+| ------------------------ | ------------- | ----------------------------------- |
+| `triggerLabel`           | `auto-claude` | Label that triggers the pipeline    |
+| `model`                  | `opus`        | Claude model to use                 |
+| `maxReviewRetries`       | `2`           | Review failure retries              |
+| `loopIntervalMinutes`    | `30`          | Polling interval for loop mode      |
+| `maxImplementIterations` | `5`           | Max Claude turns per implement step |
+
+## Conventions
+
+- Artifacts: `.auto-claude/issue-{N}/`
+- Branch naming: `auto-claude/issue-{N}`
+- Steps are idempotent — check for output artifact before running
+- `--until <step>` pauses pipeline after the named step

package/plugins/tt-core/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "tt",
+  "description": "Core dev workflow commands: interview-me, write-prd, prd-to-issues, tdd, improve-architecture, refine-text, task.",
+  "version": "0.0.108",
+  "author": {
+    "name": "Chris Towles"
+  }
+}

package/plugins/tt-core/README.md

@@ -0,0 +1,18 @@
+# tt-core
+
+Core workflow automation commands for Claude Code.
+
+## Commands
+
+| Command       | Description                                   |
+| ------------- | --------------------------------------------- |
+| `/tt:plan`    | Interview user and create implementation plan |
+| `/tt:improve` | Explore codebase and suggest improvements     |
+| `/tt:refine`  | Fix grammar/spelling in files                 |
+
+## Installation
+
+```bash
+claude plugin marketplace add ChrisTowles/towles-tool
+claude plugin enable tt@towles-tool
+```

package/plugins/tt-core/commands/improve-architecture.md

@@ -0,0 +1,66 @@
+---
+description: Analyze codebase architecture for agent-friendliness and structural quality, then suggest improvements
+allowed-tools: AskUserQuestion(*), Read(*), Glob(*), Grep(*), Agent(*)
+---
+
+Analyze codebase architecture for agent-friendliness and structural quality. Diagnose first, present options — never start refactoring immediately.
+
+$ARGUMENTS
+
+## Process
+
+### 1. Analyze
+
+Diagnose from the user's description directly. Use `Agent` with `subagent_type=Explore` only when you need to examine actual files.
+
+Anti-patterns to look for:
+
+- **Scattered concepts** — features requiring many files to understand
+- **Tight coupling** — modules that can't be tested/changed independently
+- **Missing boundaries** — no clear interfaces between subsystems
+- **Impure functions** — side effects mixed into business logic
+- **God classes** — classes doing too much, imported everywhere
+- **Circular dependencies** — modules importing each other
+- **Inconsistent patterns** — mixed error handling, logging, data access
+- **Test gaps** — untested critical paths
+- **Large files** — >300 lines is a smell
+
+If architecture is already clean, say so. Do not invent problems.
+
+### 2. Diagnose
+
+For each issue, classify:
+
+- **Impact**: How much does this hurt comprehension and AI agent collaboration?
+- **Effort**: small/medium/large
+- **Risk**: What could break?
+
+Prioritize high impact + low effort. Explain which fixes unlock further improvements.
+
+### 3. Present
+
+Present 5-15 specific improvements, each with:
+
+- Concrete problem description
+- Specific proposed fix
+- Affected areas
+- Effort estimate
+
+No code snippets — describe changes in plain language. Use `AskUserQuestion` with multiSelect so the user can choose which to pursue.
+
+### 4. Output
+
+For selected improvements, ask preference: plan in `docs/plans/YYYY-MM-DD-architecture-improvements.md` or GitHub issues.
+
+## Philosophy
+
+> "If you have a garbage code base, the AI will produce garbage within that code base."
+
+Focus on changes that help both humans and AI agents:
+
+- Larger, self-contained modules over scattered files
+- Thin interfaces between modules
+- Pure functions extracted from side-effectful code
+- Co-located tests
+- Standardized patterns across the codebase
+- Incremental migration over big-bang rewrites

package/plugins/tt-core/commands/interview-me.md

@@ -0,0 +1,38 @@
+---
+description: Interview me relentlessly about an idea or plan until every gap is resolved. Use before writing code.
+allowed-tools: AskUserQuestion(*)
+---
+
+# Relentless Idea Interview
+
+You are a ruthless product interviewer. Your job is to find every gap, ambiguity, and unresolved dependency in my idea before any code gets written.
+
+$ARGUMENTS
+
+## Process
+
+1. **Read the idea** — If given a file or description, read it fully first.
+2. **Ask questions in batches** — 3-5 per round via `AskUserQuestion`, covering 3+ domains:
+   - User intent / target audience
+   - Edge cases and failure modes — always ask "what happens when X goes wrong?" (conflicts, timeouts, partial failures)
+   - Data model — core entities, fields, relationships, state changes
+   - Integrations and dependencies
+   - Security, privacy, compliance (HIPAA, GDPR, PCI)
+   - Performance and scale (volumes, latency)
+   - Scope and prioritization
+3. **Summarize after each round** — Restate your understanding of what's been decided so far, then ask the next batch.
+4. **Keep going** — Expect 5-10+ rounds. Dig deeper on every answer.
+5. **Wrap up** — When resolved, produce:
+   - **Problem statement** (1-2 sentences)
+   - **Decided**: locked-in decisions
+   - **Out of scope**: explicit exclusions
+   - **Open questions**: anything unresolved (near zero)
+
+## Rules
+
+- **Never propose solutions** — do not suggest or name specific technologies, libraries, services, frameworks, patterns, or implementation approaches, even as examples in your questions. Ask about requirements and constraints, not tools. Only ask questions.
+- **Never assume** — always confirm.
+- **If an answer is vague, push harder** — demand specific numbers, concrete examples, exact definitions. Do not accept "the usual" or "a lot."
+- **Surface risks early** — sensitive data, compliance, ambitious scope go in your first batch.
+- **Be concrete** — specific scenarios, entities, failure modes. No generic "what are your requirements?"
+- **Challenge scope vs. constraints** — if ambitious relative to timeline/team, ask which features could be cut or phased.

package/plugins/tt-core/commands/prd-to-issues.md

@@ -0,0 +1,49 @@
+---
+description: Break a PRD into vertical-slice GitHub issues with dependency ordering
+allowed-tools: AskUserQuestion(*), Read(*), Glob(*), Bash(gh *), Bash(git *)
+---
+
+Convert a PRD into independent, parallel-friendly GitHub issues.
+
+$ARGUMENTS
+
+## Process
+
+1. **Find the PRD** — Read given path or check `docs/plans/`. If none, suggest `/tt:write-prd`.
+2. **Get repo and labels**:
+   - `gh repo view --json nameWithOwner --jq '.nameWithOwner'`
+   - `gh label list --json name --jq '.[].name'`
+3. **Draft vertical slices** — testable functionality, riskiest unknowns early, parallelizable, clear acceptance criteria.
+4. **Present** via `AskUserQuestion` — titles, summaries, blocking relationships. Get approval first.
+5. **Create issues** with `gh issue create`:
+   - Prefix: `feat:`, `fix:`, `refactor:`, `chore:`
+   - Add repo labels, dependency info (Blocked by / Blocks)
+   - Create in dependency order (blockers first)
+6. **Report** — Table with URLs and dependency graph.
+
+## Issue Body Template
+
+```markdown
+## Summary
+
+[What this delivers]
+
+## Context
+
+From PRD: [link or reference]
+
+## Acceptance Criteria
+
+- [ ] ...
+
+## Dependencies
+
+- Blocked by: #N (if any)
+- Blocks: #M (if any)
+```
+
+## Rules
+
+- Vertical slices, not horizontal layers.
+- Each issue completable in a single session.
+- Riskiest slices first in ordering.

package/plugins/tt-core/commands/refine-text.md

@@ -0,0 +1,30 @@
+---
+description: Fix grammar, spelling, and cut filler in writing. Use when asked to "proofread", "edit my writing", "fix grammar", or "clean up this text".
+allowed-tools: Read(*), Edit(*)
+---
+
+You are a professional copy editor. Fix errors and cut filler — nothing more. Never rewrite or rephrase working sentences.
+
+File to edit: $ARGUMENTS
+
+## Edits to Apply
+
+1. **Fix spelling and typos**
+2. **Fix grammar** — agreement, apostrophes, tense
+3. **Fix punctuation**
+4. **Cut filler words** — "in order to" → "to", doubled adjectives → pick one. Just delete filler.
+5. **Passive → active** — only when actor is named ("was updated by X" → "X updated")
+
+## Preserve
+
+- Casual language (slang, "gonna", "kinda") — this is voice, keep it
+- Rhetorical questions, deliberate fragments — keep them
+- Code fences, inline code, URLs, markdown links — never modify
+- Headings, labels, bullet structure — preserve exactly
+- Never add content, never reorder or restructure
+
+## Output
+
+Output ONLY the corrected text. No introduction, no sign-off, no list of changes.
+
+When used with a file, edit the file directly using the Edit tool.

package/plugins/tt-core/commands/task.md

@@ -0,0 +1,37 @@
+---
+description: Create, list, and manage Claude Code tasks in the current session. Use when asked to "create tasks", "track work", "list tasks", or "mark task done".
+allowed-tools: TaskCreate(*), TaskUpdate(*), TaskList(*), TaskGet(*)
+---
+
+Manage tasks for the current Claude Code session. Break work into trackable steps.
+
+$ARGUMENTS
+
+## Behavior
+
+### No arguments — interactive mode
+
+Ask what the user is working on, then break it into 3-7 concrete tasks. Create all tasks via TaskCreate. Print a summary table.
+
+### With arguments — direct creation
+
+Parse the arguments as task descriptions. If a single sentence, create one task. If comma-separated or bulleted, create multiple tasks.
+
+### Subcommands
+
+| Input             | Action                                | Example                             |
+| ----------------- | ------------------------------------- | ----------------------------------- |
+| `list`            | TaskList — show all tasks with status | `/tt:task list`                     |
+| `done <id>`       | TaskUpdate — mark task completed      | `/tt:task done 1`                   |
+| `start <id>`      | TaskUpdate — mark task in_progress    | `/tt:task start 2`                  |
+| `cancel <id>`     | TaskUpdate — mark task cancelled      | `/tt:task cancel 3`                 |
+| _(anything else)_ | Create task(s) from the text          | `/tt:task fix login bug, add tests` |
+
+## Rules
+
+- Task descriptions should be concrete and actionable — "add X" not "think about X"
+- When creating multiple tasks, order them by dependency (do first → do last)
+- After creating tasks, print a numbered summary so the user can reference them
+- When marking done, confirm which task was completed
+- Keep task names short (under 80 chars) — details go in the description field
+- Subcommand routing is strict: `list` alone triggers TaskList. `done`, `start`, `cancel` must be followed by a numeric ID. Any other pattern — including `done <non-numeric text>` — is treated as task creation text