claude-code-workflow 7.2.30 → 7.3.0

package/.codex/skills/team-coordinate/roles/coordinator/commands/monitor.md

@@ -233,7 +233,7 @@ All tasks completed (no pending, no in_progress)
   +- Read session.completion_action:
       |
       +- "interactive":
-      |   request_user_input({
+      |   functions.request_user_input({
       |     questions: [{
       |       question: "Team pipeline complete. What would you like to do?",
       |       header: "Completion",

package/.codex/skills/team-designer/SKILL.md

@@ -39,6 +39,9 @@ Generate complete team skills following the team-lifecycle-v4 architecture: SKIL
 ## Execution Flow
 
 ```
+Progress Tracking Initialization:
+   └─ functions.update_plan([all 4 phases, Phase 1 as in_progress])
+
 Input Parsing:
    └─ Parse user requirements (skill name, roles, pipelines, domain)
 
@@ -46,20 +49,24 @@ Phase 1: Requirements Analysis
    └─ Ref: phases/01-requirements-analysis.md
       ├─ Tasks: Detect input → Gather roles → Define pipelines → Build teamConfig
       └─ Output: teamConfig
+      └─ Progress: mark phase-1 completed, phase-2 in_progress
 
 Phase 2: Scaffold Generation
    └─ Ref: phases/02-scaffold-generation.md
       ├─ Tasks: Create dirs → Generate SKILL.md router → Verify
       └─ Output: SKILL.md + directory structure
+      └─ Progress: mark phase-2 completed, phase-3 in_progress
 
 Phase 3: Content Generation
    └─ Ref: phases/03-content-generation.md
       ├─ Tasks: Coordinator → Workers → Specs → Templates
       └─ Output: roles/**/*.md, specs/*.md, templates/*.md
+      └─ Progress: mark phase-3 completed, phase-4 in_progress
 
 Phase 4: Validation
    └─ Ref: phases/04-validation.md
       └─ Output: Validation report (PASS/REVIEW/FAIL)
+      └─ Progress: mark phase-4 completed
 
 Return:
    └─ Summary with skill location and usage instructions
@@ -101,6 +108,25 @@ Generated skills follow the architecture of `~  or <project>/.claude/skills/team
 └── templates/                            # Optional document templates
 ```
 
+## Progress Tracking
+
+Initialize progress tracking before Phase 1 execution:
+
+```
+functions.update_plan([
+  { id: "phase-1", title: "Phase 1: Requirements Analysis", status: "in_progress" },
+  { id: "phase-2", title: "Phase 2: Scaffold Generation", status: "pending" },
+  { id: "phase-3", title: "Phase 3: Content Generation", status: "pending" },
+  { id: "phase-4", title: "Phase 4: Validation", status: "pending" }
+])
+```
+
+At each phase transition:
+- **Phase 1 complete**: `functions.update_plan([{id: "phase-1", status: "completed"}, {id: "phase-2", status: "in_progress"}])`
+- **Phase 2 complete**: `functions.update_plan([{id: "phase-2", status: "completed"}, {id: "phase-3", status: "in_progress"}])`
+- **Phase 3 complete**: `functions.update_plan([{id: "phase-3", status: "completed"}, {id: "phase-4", status: "in_progress"}])`
+- **Phase 4 complete**: `functions.update_plan([{id: "phase-4", status: "completed"}])`
+
 ## Data Flow
 
 ```
@@ -126,7 +152,7 @@ Return summary to user
 
 ## Core Rules
 
-1. **Start Immediately**: First action is Phase 1 execution
+1. **Start Immediately**: First action is progress tracking initialization, second action is Phase 1 execution
 2. **Parse Every Output**: Extract teamConfig from Phase 1 for subsequent phases
 3. **Auto-Continue**: After each phase, automatically execute next phase
 4. **Progressive Phase Loading**: Read phase docs ONLY when that phase is about to execute

package/.codex/skills/team-designer/phases/01-requirements-analysis.md

@@ -34,11 +34,11 @@ function detectInputSource(userInput) {
 ## Step 1.2: Gather Core Identity
 
 ```javascript
-const skillNameResponse = request_user_input({
+const skillNameResponse = functions.request_user_input({
   prompt: `团队技能名称？(kebab-case, e.g., team-code-review)\n\nSuggested: ${suggestedName}\nOr enter a custom name.`
 });
 
-const prefixResponse = request_user_input({
+const prefixResponse = functions.request_user_input({
   prompt: `会话前缀？(3-4字符用于任务ID, e.g., TCR)\n\nSuggested: ${suggestedPrefix}\nOr enter a custom prefix.`
 });
 ```

package/.codex/skills/team-designer/phases/02-scaffold-generation.md

@@ -158,7 +158,7 @@ Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5
 When pipeline completes, coordinator presents:
 
 \```
-request_user_input({
+functions.request_user_input({
   prompt: "Pipeline complete. What would you like to do?\n\nOptions:\n1. Archive & Clean (Recommended) - Archive session, clean up team\n2. Keep Active - Keep session for follow-up work\n3. Export Results - Export deliverables to target directory"
 })
 \```

package/.codex/skills/team-designer/phases/04-validation.md

@@ -296,7 +296,7 @@ Usage:
 
 ```javascript
 if (report.gate === 'FAIL') {
-  const recovery = request_user_input({
+  const recovery = functions.request_user_input({
     prompt: `Validation found ${report.errors.length} errors. How to proceed?\n\nOptions:\n1. Auto-fix - Attempt automatic fixes (missing files, frontmatter)\n2. Regenerate - Re-run Phase 3 with fixes\n3. Accept as-is - Manual fix later`
   });
 }

package/.codex/skills/team-executor/SKILL.md

@@ -1,218 +1,218 @@
----
-name: team-executor
-description: Lightweight session execution skill. Resumes existing team-coordinate sessions for pure execution via team-worker agents. No analysis, no role generation -- only loads and executes. Session path required. Triggers on "Team Executor".
-allowed-tools: spawn_agent(*), wait_agent(*), send_message(*), assign_task(*), close_agent(*), list_agents(*), report_agent_job_result(*), request_user_input(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*)
----
-
-# Team Executor
-
-Lightweight session execution skill: load session -> reconcile state -> spawn team-worker agents -> execute -> deliver. **No analysis, no role generation** -- only executes existing team-coordinate sessions.
-
-
-## Architecture
-
-```
-+---------------------------------------------------+
-|  Skill(skill="team-executor")                      |
-|  args="--session=<path>" [REQUIRED]                |
-+-------------------+-------------------------------+
-                    | Session Validation
-         +---- --session valid? ----+
-         | NO                       | YES
-         v                          v
-    Error immediately          Orchestration Mode
-    (no session)               -> executor
-                                    |
-                    +-------+-------+-------+
-                    v       v       v       v
-                 [team-worker agents loaded from session role-specs]
-```
-
----
-
-## Session Validation (BEFORE routing)
-
-**CRITICAL**: Session validation MUST occur before any execution.
-
-### Parse Arguments
-
-Extract from `$ARGUMENTS`:
-- `--session=<path>`: Path to team-coordinate session folder (REQUIRED)
-
-### Validation Steps
-
-1. **Check `--session` provided**:
-   - If missing -> **ERROR**: "Session required. Usage: --session=<path-to-TC-folder>"
-
-2. **Validate session structure** (see specs/session-schema.md):
-   - Directory exists at path
-   - `team-session.json` exists and valid JSON
-   - `task-analysis.json` exists and valid JSON
-   - `role-specs/` directory has at least one `.md` file
-   - Each role in `team-session.json#roles` has corresponding `.md` file in `role-specs/`
-
-3. **Validation failure**:
-   - Report specific missing component
-   - Suggest re-running team-coordinate or checking path
-
----
-
-## Role Router
-
-This skill is **executor-only**. Workers do NOT invoke this skill -- they are spawned as `team-worker` agents directly.
-
-### Dispatch Logic
-
-| Scenario | Action |
-|----------|--------|
-| No `--session` | **ERROR** immediately |
-| `--session` invalid | **ERROR** with specific reason |
-| Valid session | Orchestration Mode -> executor |
-
-### Orchestration Mode
-
-**Invocation**: `Skill(skill="team-executor", args="--session=<session-folder>")`
-
-**Lifecycle**:
-```
-Validate session
-  -> executor Phase 0: Reconcile state (reset interrupted, detect orphans)
-  -> executor Phase 1: Spawn first batch team-worker agents (background) -> STOP
-  -> Worker executes -> callback -> executor advances next step
-  -> Loop until pipeline complete -> Phase 2 report + completion action
-```
-
-**User Commands** (wake paused executor):
-
-| Command | Action |
-|---------|--------|
-| `check` / `status` | Output execution status graph, no advancement |
-| `resume` / `continue` | Check worker states, advance next step |
-
----
-
-## Role Registry
-
-| Role | File | Type |
-|------|------|------|
-| executor | [roles/executor/role.md](roles/executor/role.md) | built-in orchestrator |
-| (dynamic) | `<session>/role-specs/<role-name>.md` | loaded from session |
-
----
-
-## Executor Spawn Template
-
-### v2 Worker Spawn (all roles)
-
-When executor spawns workers, use `team-worker` agent with role-spec path:
-
-```
-spawn_agent({
-  agent_type: "team_worker",
-  task_name: "<task-id>",
-  fork_context: false,
-  items: [
-    { type: "text", text: `## Role Assignment
-role: <role>
-role_spec: <session-folder>/role-specs/<role>.md
-session: <session-folder>
-session_id: <session-id>
-requirement: <task-description>
-inner_loop: <true|false>
-
-Read role_spec file to load Phase 2-4 domain instructions.` },
-
-    { type: "text", text: `## Task Context
-task_id: <task-id>
-title: <task-title>
-description: <task-description>
-pipeline_phase: <pipeline-phase>` },
-
-    { type: "text", text: `## Upstream Context
-<prev_context>` }
-  ]
-})
-```
-
-After spawning, use `wait_agent({ targets: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ target: <name> })` each worker.
-
----
-
-
-### Model Selection Guide
-
-team-executor loads roles dynamically from session role-specs. Use reasoning_effort based on the role type defined in the session:
-- Implementation/fix roles: `reasoning_effort: "high"`
-- Verification/test roles: `reasoning_effort: "medium"`
-- Default when role type is unclear: `reasoning_effort: "high"`
-
-## v4 Agent Coordination
-
-### State Reconciliation
-
-On resume, executor reconciles session state with actual running agents:
-```
-const running = list_agents({})
-// Compare with session's task-analysis.json active tasks
-// Reset orphaned tasks (in_progress but agent gone) to pending
-```
-
-### Worker Communication
-
-- `send_message({ target: "<task-id>", items: [...] })` -- queue supplementary context
-- `assign_task({ target: "<task-id>", items: [...] })` -- assign new work to inner_loop worker
-- `close_agent({ target: "<task-id>" })` -- cleanup completed worker
-
-## Completion Action
-
-When pipeline completes (all tasks done), executor presents an interactive choice:
-
-```
-request_user_input({
-  questions: [{
-    question: "Team pipeline complete. What would you like to do?",
-    header: "Completion",
-    multiSelect: false,
-    options: [
-      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up team" },
-      { label: "Keep Active", description: "Keep session for follow-up work" },
-      { label: "Export Results", description: "Export deliverables to target directory, then clean" }
-    ]
-  }]
-})
-```
-
-### Action Handlers
-
-| Choice | Steps |
-|--------|-------|
-| Archive & Clean | Update session status="completed" -> output final summary with artifact paths |
-| Keep Active | Update session status="paused" -> output: "Resume with: Skill(skill='team-executor', args='--session=<path>')" |
-| Export Results | request_user_input(target path) -> copy artifacts to target -> Archive & Clean |
-
----
-
-## Integration with team-coordinate
-
-| Scenario | Skill |
-|----------|-------|
-| New task, no session | team-coordinate |
-| Existing session, resume execution | **team-executor** |
-| Session needs new roles | team-coordinate (with resume) |
-| Pure execution, no analysis | **team-executor** |
-
----
-
-## Error Handling
-
-| Scenario | Resolution |
-|----------|------------|
-| No --session provided | ERROR immediately with usage message |
-| Session directory not found | ERROR with path, suggest checking path |
-| team-session.json missing | ERROR, session incomplete, suggest re-run team-coordinate |
-| task-analysis.json missing | ERROR, session incomplete, suggest re-run team-coordinate |
-| No role-specs in session | ERROR, session incomplete, suggest re-run team-coordinate |
-| Role-spec file not found | ERROR with expected path |
-| capability_gap reported | Warn only, cannot generate new role-specs |
-| Fast-advance spawns wrong task | Executor reconciles on next callback |
-| Completion action fails | Default to Keep Active, log warning |
+---
+name: team-executor
+description: Lightweight session execution skill. Resumes existing team-coordinate sessions for pure execution via team-worker agents. No analysis, no role generation -- only loads and executes. Session path required. Triggers on "Team Executor".
+allowed-tools: spawn_agent(*), wait_agent(*), send_message(*), assign_task(*), close_agent(*), list_agents(*), report_agent_job_result(*), request_user_input(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*)
+---
+
+# Team Executor
+
+Lightweight session execution skill: load session -> reconcile state -> spawn team-worker agents -> execute -> deliver. **No analysis, no role generation** -- only executes existing team-coordinate sessions.
+
+
+## Architecture
+
+```
++---------------------------------------------------+
+|  Skill(skill="team-executor")                      |
+|  args="--session=<path>" [REQUIRED]                |
++-------------------+-------------------------------+
+                    | Session Validation
+         +---- --session valid? ----+
+         | NO                       | YES
+         v                          v
+    Error immediately          Orchestration Mode
+    (no session)               -> executor
+                                    |
+                    +-------+-------+-------+
+                    v       v       v       v
+                 [team-worker agents loaded from session role-specs]
+```
+
+---
+
+## Session Validation (BEFORE routing)
+
+**CRITICAL**: Session validation MUST occur before any execution.
+
+### Parse Arguments
+
+Extract from `$ARGUMENTS`:
+- `--session=<path>`: Path to team-coordinate session folder (REQUIRED)
+
+### Validation Steps
+
+1. **Check `--session` provided**:
+   - If missing -> **ERROR**: "Session required. Usage: --session=<path-to-TC-folder>"
+
+2. **Validate session structure** (see specs/session-schema.md):
+   - Directory exists at path
+   - `team-session.json` exists and valid JSON
+   - `task-analysis.json` exists and valid JSON
+   - `role-specs/` directory has at least one `.md` file
+   - Each role in `team-session.json#roles` has corresponding `.md` file in `role-specs/`
+
+3. **Validation failure**:
+   - Report specific missing component
+   - Suggest re-running team-coordinate or checking path
+
+---
+
+## Role Router
+
+This skill is **executor-only**. Workers do NOT invoke this skill -- they are spawned as `team-worker` agents directly.
+
+### Dispatch Logic
+
+| Scenario | Action |
+|----------|--------|
+| No `--session` | **ERROR** immediately |
+| `--session` invalid | **ERROR** with specific reason |
+| Valid session | Orchestration Mode -> executor |
+
+### Orchestration Mode
+
+**Invocation**: `Skill(skill="team-executor", args="--session=<session-folder>")`
+
+**Lifecycle**:
+```
+Validate session
+  -> executor Phase 0: Reconcile state (reset interrupted, detect orphans)
+  -> executor Phase 1: Spawn first batch team-worker agents (background) -> STOP
+  -> Worker executes -> callback -> executor advances next step
+  -> Loop until pipeline complete -> Phase 2 report + completion action
+```
+
+**User Commands** (wake paused executor):
+
+| Command | Action |
+|---------|--------|
+| `check` / `status` | Output execution status graph, no advancement |
+| `resume` / `continue` | Check worker states, advance next step |
+
+---
+
+## Role Registry
+
+| Role | File | Type |
+|------|------|------|
+| executor | [roles/executor/role.md](roles/executor/role.md) | built-in orchestrator |
+| (dynamic) | `<session>/role-specs/<role-name>.md` | loaded from session |
+
+---
+
+## Executor Spawn Template
+
+### v2 Worker Spawn (all roles)
+
+When executor spawns workers, use `team-worker` agent with role-spec path:
+
+```
+spawn_agent({
+  agent_type: "team_worker",
+  task_name: "<task-id>",
+  fork_context: false,
+  items: [
+    { type: "text", text: `## Role Assignment
+role: <role>
+role_spec: <session-folder>/role-specs/<role>.md
+session: <session-folder>
+session_id: <session-id>
+requirement: <task-description>
+inner_loop: <true|false>
+
+Read role_spec file to load Phase 2-4 domain instructions.` },
+
+    { type: "text", text: `## Task Context
+task_id: <task-id>
+title: <task-title>
+description: <task-description>
+pipeline_phase: <pipeline-phase>` },
+
+    { type: "text", text: `## Upstream Context
+<prev_context>` }
+  ]
+})
+```
+
+After spawning, use `wait_agent({ targets: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ target: <name> })` each worker.
+
+---
+
+
+### Model Selection Guide
+
+team-executor loads roles dynamically from session role-specs. Use reasoning_effort based on the role type defined in the session:
+- Implementation/fix roles: `reasoning_effort: "high"`
+- Verification/test roles: `reasoning_effort: "medium"`
+- Default when role type is unclear: `reasoning_effort: "high"`
+
+## v4 Agent Coordination
+
+### State Reconciliation
+
+On resume, executor reconciles session state with actual running agents:
+```
+const running = list_agents({})
+// Compare with session's task-analysis.json active tasks
+// Reset orphaned tasks (in_progress but agent gone) to pending
+```
+
+### Worker Communication
+
+- `send_message({ target: "<task-id>", items: [...] })` -- queue supplementary context
+- `assign_task({ target: "<task-id>", items: [...] })` -- assign new work to inner_loop worker
+- `close_agent({ target: "<task-id>" })` -- cleanup completed worker
+
+## Completion Action
+
+When pipeline completes (all tasks done), executor presents an interactive choice:
+
+```
+functions.request_user_input({
+  questions: [{
+    question: "Team pipeline complete. What would you like to do?",
+    header: "Completion",
+    multiSelect: false,
+    options: [
+      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up team" },
+      { label: "Keep Active", description: "Keep session for follow-up work" },
+      { label: "Export Results", description: "Export deliverables to target directory, then clean" }
+    ]
+  }]
+})
+```
+
+### Action Handlers
+
+| Choice | Steps |
+|--------|-------|
+| Archive & Clean | Update session status="completed" -> output final summary with artifact paths |
+| Keep Active | Update session status="paused" -> output: "Resume with: Skill(skill='team-executor', args='--session=<path>')" |
+| Export Results | functions.request_user_input(target path) -> copy artifacts to target -> Archive & Clean |
+
+---
+
+## Integration with team-coordinate
+
+| Scenario | Skill |
+|----------|-------|
+| New task, no session | team-coordinate |
+| Existing session, resume execution | **team-executor** |
+| Session needs new roles | team-coordinate (with resume) |
+| Pure execution, no analysis | **team-executor** |
+
+---
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| No --session provided | ERROR immediately with usage message |
+| Session directory not found | ERROR with path, suggest checking path |
+| team-session.json missing | ERROR, session incomplete, suggest re-run team-coordinate |
+| task-analysis.json missing | ERROR, session incomplete, suggest re-run team-coordinate |
+| No role-specs in session | ERROR, session incomplete, suggest re-run team-coordinate |
+| Role-spec file not found | ERROR with expected path |
+| capability_gap reported | Warn only, cannot generate new role-specs |
+| Fast-advance spawns wrong task | Executor reconciles on next callback |
+| Completion action fails | Default to Keep Active, log warning |