npm - aiwcli - Versions diffs - 0.15.5 → 0.17.0 - Mend

aiwcli 0.15.5 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (435) hide show

package/dist/templates/_shared/.codex/workflows/handoff.md DELETED Viewed

@@ -1,226 +0,0 @@
-# Handoff Workflow
-Generate a handoff document summarizing the current session's work, decisions, and pending items. Optionally update a plan document to track completed vs remaining tasks.
-## Triggers
-- `/handoff` command
-- `/handoff path/to/PLAN.md` - with plan document integration
-- Phrases like "write a handoff", "create a session summary", "document what we did", "end session with notes"
-## Arguments
-- `$ARGUMENTS` - Optional path to a plan document. If provided, the handoff will:
-  1. Mark completed items in the plan with `[x]`
-  2. Add notes about partial progress
-  3. Append a "Session Progress" section to the plan
-## Process
-### Step 1: Get Context ID
-Extract the `context_id` from the system reminder injected by the context enforcer hook.
-Look for the pattern in the system reminder:
-```
-Active Context: {context_id}
-```
-If no active context is found, inform the user and stop - handoffs require an active context.
-### Step 2: Gather Information
-1. Review conversation history for:
-   - Completed tasks and implementations
-   - Key decisions and their rationale
-   - Failed approaches (to avoid repeating)
-   - External context (deadlines, stakeholder requirements)
-2. Check git status if available:
-   ```bash
-   git status --short
-   git diff --stat
-   ```
-3. Look for TODOs/FIXMEs mentioned in session
-4. **If plan document provided**: Read the plan and identify:
-   - Tasks that are now completed
-   - Tasks that are partially done
-   - Tasks that were attempted but blocked
-   - New tasks discovered during implementation
-### Step 3: Generate Document
-Use this template. The `<!-- SECTION: name -->` markers are required for the save script to parse sections into sharded files.
-```markdown
----
-title: Session Handoff
-date: {ISO timestamp}
-session_id: {conversation ID if available}
-project: {project name from package.json, Cargo.toml, or directory name}
-context_id: {context_id from Step 1}
-plan_document: {path to plan if provided, or "none"}
----
-# Session Handoff — {Date}
-<!-- SECTION: summary -->
-## Summary
-{2-3 sentences: what's different now vs. session start}
-<!-- SECTION: completed -->
-## Work Completed
-{Grouped by category if multiple areas. Specific file:function references.}
-<!-- SECTION: dead-ends -->
-## Dead Ends — Do Not Retry
-These approaches were attempted and failed. Do not retry without addressing the root cause.
-| Approach | Why It Failed | Time Spent | Alternative |
-|----------|---------------|------------|-------------|
-| {What was attempted} | {Specific reason} | {Rough estimate} | {What to try instead} |
-<!-- SECTION: decisions -->
-## Key Decisions
-{Technical choices with rationale. Format: **Decision**: Rationale. Trade-off: X.}
-<!-- SECTION: pending -->
-## Pending Issues
-- [ ] {Issue} — {severity: HIGH/MED/LOW} {optional workaround note}
-<!-- SECTION: next-steps -->
-## Next Steps
-1. {Actionable item with file:line reference if applicable}
-<!-- SECTION: files -->
-## Files Modified
-{Significant changes only. Skip formatting-only edits.}
-<!-- SECTION: context -->
-## Context for Future Sessions
-{Non-obvious context: env quirks, stakeholder requirements}
-```
-### Step 4: Update Plan Document (if provided)
-If a plan document path was provided in `$ARGUMENTS`:
-1. **Read the plan document**
-2. **Identify completed items**:
-   - Find checkboxes `- [ ]` that match completed work
-   - Change them to `- [x]`
-3. **Add progress notes** to items that are partially complete:
-   - Append `(partial: {brief status})` to the line
-4. **Append Session Progress section** at the bottom:
-```markdown
----
-## Session Progress Log
-### {Date} — Session {session_id or timestamp}
-**Completed this session:**
-- [x] {Task from plan that was completed}
-- [x] {Another completed task}
-**Partially completed:**
-- {Task} — {current state, what remains}
-**Blocked/Deferred:**
-- {Task} — {reason, what's needed}
-**New items discovered:**
-- [ ] {New task not in original plan}
-- [ ] {Another new task}
----
-```
-5. **If no plan document was provided**:
-   - Skip plan creation - the handoff document serves as the session record
-### Step 5: Save and Update Status
-Instead of writing the file directly, pipe your handoff content to the save script:
-```bash
-bun .aiwcli/_shared/skills/handoff-system/scripts/save_handoff.ts "{context_id}" <<'EOF'
-{Your complete handoff markdown content from Step 3}
-EOF
-```
-This script:
-1. Creates a folder at `_output/contexts/{context_id}/handoffs/{YYYY-MM-DD-HHMM}/`
-2. Parses sections and writes sharded files (index.md, completed-work.md, dead-ends.md, etc.)
-3. Copies the current plan (if any) to plan.md
-4. Records the event in the context's event log (informational only)
-Use the handoff folder for context in the next session.
-## Dead Ends Section Guidelines
-This section is critical for preventing context rot across sessions. Be specific:
-**Bad (too vague):**
-> - Tried using library X, didn't work
-**Good (actionable):**
-> ### Fixing the race condition in SessionStore
-> | Approach Tried | Why It Failed |
-> |----------------|---------------|
-> | `async-mutex` package | Deadlock when nested calls to `getSession()` |
-> | Redis WATCH/MULTI | Our Redis 6.x cluster doesn't support WATCH in cluster mode |
-> | In-memory lock Map | Works single-node but breaks in horizontal scaling |
->
-> **What to try instead**: Upgrade to Redis 7.x which supports WATCH in cluster mode, or use Redlock algorithm
-**Capture these dead ends:**
-- Packages/libraries that had incompatibilities
-- Approaches that caused new bugs or regressions
-- Solutions that worked locally but failed in CI/staging/prod
-- Configurations that conflicted with existing setup
-- Rabbit holes that consumed significant time without progress
-## Post-Generation Output
-After creating file, output:
-```
-✓ Created handoff folder: _output/contexts/{context_id}/handoffs/{YYYY-MM-DD-HHMM}/
-  - index.md (entry point with navigation)
-  - completed-work.md, dead-ends.md, decisions.md, pending.md, context.md
-  - plan.md (copy of current plan, if any)
-To continue next session:
-  The index.md will be automatically suggested when you start a new session.
-  Read dead-ends.md first to avoid repeating failed approaches.
-⚠️  {N} dead ends documented — avoid re-attempting these approaches
-```
-If plan was updated:
-```
-✓ Updated plan document: {path}
-   - {N} items marked complete
-   - {N} items partially complete
-   - {N} new items added
-```
-## Success Criteria
-- [ ] Handoff folder created at `handoffs/{YYYY-MM-DD-HHMM}/`
-- [ ] index.md contains summary and navigation table
-- [ ] All section files created (completed-work.md, dead-ends.md, etc.)
-- [ ] Dead ends use structured table format for quick scanning
-- [ ] plan.md copied from context if plan exists
-- [ ] Next steps are actionable with file references
-- [ ] Git status included in index.md
-- [ ] If plan provided: checkboxes updated to reflect completion status
-- [ ] If plan provided: Session Progress Log appended
-- [ ] Context state updated to indicate handoff pending

package/dist/templates/_shared/.codex/workflows/meta-plan.md DELETED Viewed

@@ -1,347 +0,0 @@
-# MetaPlan Workflow
-> **Trigger:** "meta-plan", "chain thinking", "dissect problem", "comprehensive plan", "help me figure out the right approach"
-## Reference Material
-- `../CLAUDE.md` — MetaPlan system spec: purpose, design decisions, constraints
----
-A workflow for complex problems where choosing the right approach is harder than implementing it. Chains thinking categories together to produce a comprehensive, reviewable plan before any implementation begins.
-## When to Use
-- Problems with high ambiguity or large solution spaces
-- Multiple valid approaches where the trade-offs are unclear
-- Unfamiliar domains requiring structured exploration before commitment
-- Multi-stakeholder problems needing multiple perspectives
-- Any situation where "version 1" quality matters and rework is expensive
-## When NOT to Use
-- The solution is already known — just implement it
-- Simple, well-scoped tasks with obvious approaches
-- Trivial fixes, typos, or configuration changes
----
-## Section 1 — Intent Preservation (First-Principles Decomposition)
-Decompose the user's prompt into 5 categories. **Preserve all information** from the original prompt — no summarizing, no condensing, no abbreviating. Quote verbatim where possible.
-### The 5 Decomposition Categories
-1. **Explicit wants** — what they directly asked for, quoted verbatim where possible
-2. **Implied wants** — what they expect but didn't state (inferred from context, domain norms, prior work)
-3. **Explicit constraints** — stated limitations, requirements, boundaries, deadlines
-4. **Implied constraints** — assumed limitations from context, domain norms, technical environment, prior decisions
-5. **Anti-wants** — what they explicitly or implicitly don't want (stated rejections, implied aversions, things to avoid)
-### Information Loss Check
-After completing the decomposition, **re-read the original prompt in full** and explicitly list any information not captured in the 5 categories above. This prevents silent information loss.
-Output one of:
-- A numbered list of missed information items (then incorporate them into the appropriate category)
-- "None — all information captured" (only if genuinely everything is accounted for)
-### Problem Classification
-Classify the problem along these dimensions to guide which thinking categories to apply:
-| Dimension | Assessment |
-|-----------|-----------|
-| **Ambiguity level** | How many valid interpretations exist? (Low: 1-2, Medium: 3-5, High: 5+) |
-| **Solution space size** | How many viable approaches exist? (Small: 1-2, Medium: 3-5, Large: 5+) |
-| **Domain familiarity** | How well-understood is the problem domain? (Familiar / Partially familiar / Unfamiliar) |
-| **Stakeholder count** | How many perspectives must be considered? (Single / Few / Many) |
----
-## Section 2 — Problem Classification Decision Tree
-Based on the characteristics from Section 1, select which thinking categories to apply and in what order. **Not all categories are required for every problem** — the decision tree gates execution, not just ordering.
-| Problem Profile | Categories to Apply | Rationale |
-|----------------|-------------------|-----------|
-| High ambiguity, any domain | 1 → 2 → 3 → 7 (Decomposition → Divergent → Convergent → Integration) | Must explore broadly before narrowing |
-| Large solution space, familiar domain | 1 → 2 → 4 → 5 → 7 (Decomposition → Divergent → Adversarial → Trade-off → Integration) | Need to stress-test candidates |
-| Unfamiliar domain, any ambiguity | 1 → 6 → 2 → 3 → 7 (Decomposition → Expert Synthesis → Divergent → Convergent → Integration) | Research before ideation |
-| Multi-stakeholder, moderate ambiguity | 1 → 6 → 5 → 4 → 7 (Decomposition → Expert Synthesis → Trade-off → Adversarial → Integration) | Gather perspectives, evaluate trade-offs |
-| Low ambiguity, small solution space | 1 → 4 → 7 (Decomposition → Adversarial → Integration) | Quick path: decompose, stress-test, synthesize |
-| Multiple valid approaches, familiar domain | 1 → 2 → 5 → 4 → 7 (Decomposition → Divergent → Trade-off → Adversarial → Integration) | Compare, evaluate, stress-test |
-Numbers reference the 7 categories in Section 3.
-**If no profile matches exactly:** Select the closest match, or combine elements. When in doubt, use the full sequence: 1 → 2 → 3 → 4 → 5 → 6 → 7.
----
-## Section 3 — The 7 Thinking Categories
-Each category has concrete instructions to execute directly. External skills discovered at runtime (see Section 4) can enhance any category but are never required.
-### Category 1: Decomposition
-Break the complex problem into atomic sub-problems that can be addressed independently.
-**Instructions:**
-- List every distinct sub-problem, constraint, and dependency
-- Identify which sub-problems are independent (parallelizable) vs. sequential (dependent)
-- For each sub-problem, state what "solved" looks like in one sentence
-- Map dependencies: which sub-problems must be solved before others can start
-**Output:** Numbered list of sub-problems with dependency relationships noted.
----
-### Category 2: Divergent Ideation
-Generate multiple distinct solution candidates — prioritize breadth over depth.
-**Instructions:**
-- For each sub-problem (or the whole problem if atomic), brainstorm 3-5 fundamentally different approaches
-- Each approach must differ in architecture, not just parameters (e.g., "use a queue" vs "use polling" vs "use webhooks" — not "poll every 5s" vs "poll every 10s")
-- Name each approach with a descriptive 3-5 word label
-- For each, list 1-2 key strengths and 1-2 key weaknesses in brief
-**Output:** Table of approaches per sub-problem, each with a label, strengths, and weaknesses.
----
-### Category 3: Convergent Analysis
-Narrow from many candidates to 1-3 finalists using structured evaluation.
-**Instructions:**
-- Define 3-5 evaluation criteria relevant to this problem (e.g., complexity, performance, maintainability, risk, time-to-implement)
-- Score each approach against each criterion (High / Medium / Low)
-- Identify deal-breakers: any approach that fails a critical criterion is eliminated with stated reason
-- Rank surviving approaches
-**Output:** Evaluation matrix with scores, eliminations noted, and shortlist of 1-3 surviving approaches.
----
-### Category 4: Adversarial Challenge
-Stress-test the leading approach(es) by actively trying to break them.
-**Instructions:**
-- Answer each question for the leading approach:
-  - "What is the strongest argument against this approach?"
-  - "Under what conditions does this approach fail catastrophically?"
-  - "What is the most likely way this approach produces a subtly wrong result?"
-  - "If I had to argue for a completely different approach, what would I say?"
-- For each identified weakness, either:
-  - Propose a concrete mitigation, or
-  - Acknowledge the risk explicitly with conditions under which it becomes critical
-**Output:** List of challenges with mitigations or acknowledged risks.
----
-### Category 5: Trade-off Evaluation
-Compare surviving approaches on key dimensions with explicit trade-off acknowledgment.
-**Instructions:**
-- For each pair of finalist approaches, state what you gain and what you lose by choosing one over the other
-- Identify irreversible decisions (hard to change later) vs. reversible ones (can switch cheaply)
-- State the conditions under which you would switch from the recommended approach to an alternative
-- Flag any "one-way door" decisions that deserve extra scrutiny
-**Output:** Trade-off matrix with gain/lose analysis and switching conditions.
----
-### Category 6: Expert Synthesis
-Gather domain-specific knowledge relevant to the problem.
-**Instructions:**
-- What established patterns, best practices, or prior art exist for this type of problem?
-- What domain-specific constraints or conventions apply that a non-expert might miss?
-- What are the known failure modes or anti-patterns in this domain?
-- What would a domain expert check first?
-*Note: This category operates on available knowledge. If external research tools or skills are available in the environment, use them to augment this category.*
-**Output:** Domain knowledge summary with explicit relevance to the current problem.
----
-### Category 7: Integration
-Combine all thinking outputs into a coherent, actionable plan.
-**Instructions:**
-- State the recommended approach with rationale referencing evidence from prior categories
-- List trade-offs explicitly acknowledged (from Category 5)
-- List risks explicitly accepted with mitigations (from Category 4)
-- Apply domain knowledge as validation (from Category 6, if used)
-- Define concrete next steps with enough detail to begin execution immediately
-**Output:** Structured plan document containing:
-- Problem decomposition results
-- Approaches considered with trade-offs
-- Recommended approach with rationale
-- Risk assessment with mitigations
-- Domain context applied (if Category 6 was used)
-- Actionable next steps
-- Execution Manifest (from Section 4)
----
-## Section 4 — Runtime Skill Discovery (Two-Pass)
-Before executing the thinking chain, scan for ALL available skills and commands in the current environment. Skills serve two distinct roles in MetaPlan — they can enhance the *thinking* process and/or become steps in the *execution* plan.
-### Discovery Protocol
-**Pass 1 — Enumerate:** Scan all available skills, commands, and workflows in the current environment (skill registries, help commands, workflow directories). For each, read its description or summary.
-**Pass 2 — Classify:** Place each discovered skill into one or both categories:
-**Thinking Skills** — enhance one of the 7 thinking categories during the MetaPlan process itself:
-- Decomposition-related skills → Category 1
-- Ideation/creativity skills → Category 2
-- Analysis/evaluation skills → Category 3
-- Adversarial/red-team skills → Category 4
-- Comparison/trade-off skills → Category 5
-- Research/domain-knowledge skills → Category 6
-- Synthesis/integration skills → Category 7
-**Auxiliary Skills** — relevant to *executing* the recommended solution, not to thinking about it:
-- Domain-specific tools (coding standards, linting, formatting, testing frameworks)
-- Content processing (PDF extraction, image generation, data transformation)
-- Research and information gathering (web search, content analysis)
-- Communication and output (presentation, documentation, knowledge management)
-- Automation and infrastructure (browser automation, deployment, CI/CD)
-- Any skill that the person executing the plan would benefit from knowing about
-A single skill can appear in both lists — e.g., a research skill might enhance Category 6 (Expert Synthesis) during thinking AND be a standalone step in the execution plan.
-### If Zero Skills Are Discovered
-Proceed with inline instructions only. This is the **normal path**, not a degraded path. The inline instructions in Section 3 are complete and self-contained, and the plan output uses generic step descriptions instead of skill-specific invocations.
-### Skill Inventory (Required Output)
-After discovery, output the classified inventory:
-```
-## Skill Inventory
-### Thinking Skills (enhance MetaPlan categories)
-| Skill | Maps To | Role |
-|-------|---------|------|
-| [name] | Category N | Enhances/replaces inline instructions |
-### Auxiliary Skills (available for execution plan)
-| Skill | Domain | Potential Use |
-|-------|--------|---------------|
-| [name] | [domain] | [how it helps execute the solution] |
-### Unclassified
-| Skill | Reason |
-|-------|--------|
-| [name] | Not relevant to this problem |
-```
----
-## Section 5 — Chain Execution
-Execute the thinking categories selected by the decision tree (Section 2), in the specified order.
-**Rules:**
-- Feed each category's output forward as context for subsequent categories
-- Accumulate all outputs in a running document
-- If a category's output reveals new information that changes earlier conclusions, note the update explicitly (e.g., "Category 4 revealed X, which changes the Category 2 assessment of approach Y")
-- Do not skip a selected category — if the decision tree selected it, execute it
----
-## Section 6 — Plan Synthesis
-The Integration category (Category 7) produces the final plan. This is the primary deliverable of MetaPlan — a **sequential, step-by-step execution plan** that a new session can follow mechanically.
-The plan captures in plan mode or the project's context/notes system automatically. No special output file handling is needed.
-### Part A — Analysis Summary
-Summarize the thinking work that informed the plan:
-1. **Problem decomposition** — sub-problems identified and dependency-mapped (Category 1)
-2. **Solution landscape** — approaches considered with strengths and weaknesses (Category 2)
-3. **Evaluation** — how approaches were narrowed, what was eliminated and why (Category 3, if used)
-4. **Risk assessment** — stress-test results with mitigations or accepted risks (Category 4)
-5. **Trade-off analysis** — what is gained and lost with the recommended approach (Category 5, if used)
-6. **Domain context** — relevant patterns, practices, and failure modes applied (Category 6, if used)
-7. **Recommended approach** — clear statement with rationale referencing evidence above
-### Part B — Sequential Execution Plan (Skill Chain)
-The core deliverable. A numbered sequence of steps that interleaves thinking categories and auxiliary skills into a single executable chain. Each step specifies exactly what to do, so a new session can follow it without additional context.
-**Step format:**
-```
-### Step N: [Action description]
-- **Invoke:** [Skill name, thinking category, or "manual" for inline work]
-- **Input:** [What to feed this step — output from a prior step, user context, or specific files]
-- **Expected output:** [What this step produces — be specific enough to verify completion]
-- **Feeds into:** Step M [or "Final output"]
-```
-**Branching format** (when a step's output determines the next path):
-```
-### Step N: [Decision point description]
-- **Invoke:** [Skill or category]
-- **Input:** [What to evaluate]
-- **Branch:**
-  - IF [condition A] → proceed to Step M
-  - IF [condition B] → proceed to Step P
-  - ELSE → proceed to Step Q
-```
-**Overlay format** (when a thinking category and auxiliary skill run together):
-```
-### Step N: [Combined action description]
-- **Invoke:** [Thinking category] + [Auxiliary skill]
-- **Role of thinking category:** [What the category contributes — e.g., adversarial pressure]
-- **Role of auxiliary skill:** [What the skill contributes — e.g., domain standards to test against]
-- **Input:** [Combined input context]
-- **Expected output:** [Combined output]
-```
-**Rules for building the chain:**
-- Every step must have a clear input and output — no dangling steps
-- Thinking categories from Section 3 and auxiliary skills from Section 4 can freely interleave
-- A single step can overlay a thinking category with one or more auxiliary skills when they naturally combine
-- Branching logic uses IF/ELSE based on concrete, observable conditions from the prior step's output
-- The chain must be followable by a session with zero prior context — include enough detail in each step
-- If no auxiliary skills were discovered, the chain uses thinking categories and manual inline steps only
-### Part C — Skill Inventory
-Include the full Skill Inventory from Section 4 so the executing session knows what tools are available.
-### Part D — Execution Manifest
-After completing the thinking chain, output a summary showing what ran and how:
-```
-## Execution Manifest
-| Step | Type | Skill/Category Used | Method |
-|------|------|---------------------|--------|
-| 1 | Thinking | Category 1: Decomposition | Inline |
-| 2 | Auxiliary | [discovered skill name] | Skill invocation |
-| 3 | Thinking + Auxiliary | Category 4 + [skill name] | Overlay |
-| 4 | Branch | — | IF/ELSE on Step 3 output |
-| ... | ... | ... | ... |
-```

package/dist/templates/_shared/hooks-ts/_utils/git-state.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- // Re-export from shared library — canonical location is lib-ts/base/git-state.ts
2	- export { getGitState } from "../../lib-ts/base/git-state.js";

package/dist/templates/_shared/hooks-ts/pre_compact.ts DELETED Viewed

@@ -1,49 +0,0 @@
-#!/usr/bin/env bun
-/**
- * PreCompact hook: Save state.json snapshot before context compaction.
- * Captures git state and session metadata for recovery.
- */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import { getGitState } from "../lib-ts/base/git-state.js";
-import {
-  loadHookInput, logDebug, logError, logInfo, runHook,
-} from "../lib-ts/base/hook-utils.js";
-import { nowIso } from "../lib-ts/base/utils.js";
-import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
-function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-  const sessionId = payload.session_id;
-  if (!sessionId) {
-    logDebug("pre_compact", "No session_id, skipping");
-    return;
-  }
-  const projectRoot = getProjectRoot(payload.cwd);
-  const state = getContextBySessionId(sessionId, projectRoot);
-  if (!state) {
-    logDebug("pre_compact", `No context bound to session ${sessionId}`);
-    return;
-  }
-  const gitState = getGitState(projectRoot);
-  state.last_session = {
-    ...state.last_session,
-    session_id: sessionId,
-    saved_at: nowIso(),
-    save_reason: "pre_compact",
-    git_state: gitState,
-  };
-  const [ok, err] = saveState(state.id, state, projectRoot);
-  if (ok) {
-    logInfo("pre_compact", `Saved pre-compact snapshot for ${state.id}`);
-  } else {
-    logError("pre_compact", `Failed to save state: ${err}`);
-  }
-}
-runHook(main, "pre_compact");

package/dist/templates/_shared/hooks-ts/task_create_capture.ts DELETED Viewed

@@ -1,48 +0,0 @@
-#!/usr/bin/env bun
-/**
- * PostToolUse:TaskCreate hook: Persist Claude's TaskCreate calls to state.json.
- */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import {
-  checkSkipPersistence, getToolInput, loadHookInput, logDebug,
-  logError, logInfo, logWarn, runHook, validateHookEvent,
-} from "../lib-ts/base/hook-utils.js";
-import { getContextBySessionId } from "../lib-ts/context/context-store.js";
-import { addTask } from "../lib-ts/context/task-tracker.js";
-function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-  if (!validateHookEvent(payload, "PostToolUse", "TaskCreate")) return;
-  const toolInput = getToolInput(payload);
-  if (!toolInput) return;
-  if (checkSkipPersistence(payload, "task_create_capture")) return;
-  const projectRoot = getProjectRoot(payload.cwd);
-  const sessionId = payload.session_id ?? "unknown";
-  const state = getContextBySessionId(sessionId, projectRoot);
-  if (!state) {
-    logDebug("task_create_capture", `No context for session ${sessionId}`);
-    return;
-  }
-  const subject = toolInput.subject as string | undefined;
-  if (!subject) {
-    logWarn("task_create_capture", "TaskCreate missing subject field");
-    return;
-  }
-  const description = (toolInput.description as string) ?? "";
-  const activeForm = (toolInput.activeForm as string) ?? "";
-  const task = addTask(state.id, subject, description, activeForm, sessionId, projectRoot);
-  if (task) {
-    logInfo("task_create_capture", `Persisted task ${task.id}: ${subject}`);
-  } else {
-    logError("task_create_capture", `Failed to persist task: ${subject}`);
-  }
-}
-runHook(main, "task_create_capture");