@entelligentsia/forgecli 1.0.21 → 1.0.25

package/dist/forge-payload/.base-pack/workflows/commit_task.md

@@ -27,6 +27,8 @@ deps:
 - Commit only the artifacts produced for this task; do not sweep unrelated working-tree changes into the commit. The commit boundary mirrors the task boundary.
 - Read `.forge/personas/engineer.md` first; print the persona identity line (emoji, name, tagline) to stdout before any other tool use.
 - All store I/O via `forge_store` (or `node .forge/tools/store-cli.cjs`). Never edit `.forge/store/*.json` directly.
+- **Never run `git add`/`git commit`/`git reset` yourself** — `commit-task.cjs` owns staging, boundary checks, committing, and the terminal transition (#40). Your judgement input is the message.
+- **Commit writes NO summary** (`commit` ∉ `VALID_SUMMARY_PHASES` — any `set-summary` is rejected); the tool's terminal `update-status` is this phase's only store write.
 
 ## Store-Write Verification
 
@@ -36,48 +38,49 @@ deps:
 
 ```
 
-0a. Pre-flight Gate Check:
-   - **Entity-mode resolution:** read the kickoff arguments. `--task {id}` → `entity_kind = "task"`, `record_id = {id}`. `--bug {id}` → `entity_kind = "bug"`, `record_id = {id}`. All store-cli calls below substitute `{entity_kind}` and `{record_id}` for the literal "task"/{taskId} placeholders.
-   - Run: `node .forge/tools/preflight-gate.cjs --phase commit --{entity_kind} {record_id}`
-   - Exit 1 (gate failed) → print stderr and HALT. Do not proceed; do not attempt to produce the artifact.
-   - Exit 2 (misconfiguration) → print stderr and HALT.
-   - Exit 0 → continue.
+0. Entity-mode resolution:
+   - Read the kickoff arguments. `--task {id}` → `entity_kind = "task"`, `record_id = {id}`. `--bug {id}` → `entity_kind = "bug"`, `record_id = {id}`.
 
-0b. Pipeline Step Guard (user-invoked state check):
-   - If `--force` is present in the invocation arguments, skip this step entirely.
-   - If `entity_kind == "bug"`, skip this step entirely (bug state is managed by meta-fix-bug.md).
-   - Read current task state:
-     `node .forge/tools/store-cli.cjs read task {record_id} --json`
-   - Extract the `status` field from the JSON output.
-   - Allowed states for this phase: `approved`.
-   - If the current status is NOT in the allowed set:
-     Print the following and HALT (do not proceed):
-     `× Task {record_id} is in state '{status}' — /forge:approve must complete first. To run the full pipeline: /forge:run-task {record_id}`
+1. Inspect ONCE (message material only — #40 batched-inspection rule):
+   - One `git diff --stat`; at most ONE combined `git diff` if the message needs detail.
+     Never per-file diffs, never repeated `git status` — each extra turn re-pays full context.
+   - Staging is NOT your decision — the tool derives it from the store record.
 
-1. Load Context:
-   - Read the record manifest (task or bug, per entity_kind).
-   - Read ARCHITECT_APPROVAL.md by kind — never construct the path:
-     `forge_artifact({ command:"read", entity:"{entity_kind}", entityId:"{record_id}", artifact:"architect-approval" })`
+2. Craft the commit message:
+   - Follow project conventions; include the record ID ({taskId} / {bugId}) in the subject.
+   - `Co-authored-by:` trailer from the host runtime: Claude Code →
+     `Co-authored-by: Claude <noreply@anthropic.com>`; pi / Ollama / other →
+     `Co-authored-by: {modelId} <noreply@{provider}.ai>` from the session's `provider` and
+     `modelId`; if unresolvable, omit rather than guess. Never hardcode
+     `Claude Opus 4.6 <noreply@anthropic.com>` (forge#82 regression).
+   - Git's configured `user.name`/`user.email` own authorship; never `--author`.
 
-2. Staging:
-   - Stage all record-related artifacts and the code changes:
-     - Task mode: PLAN.md, PROGRESS.md, REVIEW files, ARCHITECT_APPROVAL.md, and the implementation diff under the task directory plus modified source files.
-     - Bug mode: BUG_FIX_PLAN.md (Path B only — absent on Path A), TRIAGE.md, PROGRESS.md, REVIEW files, ARCHITECT_APPROVAL.md, the regression test, and the implementation diff.
-   - Verify no unrelated files are staged.
+3. Commit via the tool — ONE call:
+   - If the `forge_commit` named tool is available (forgecli): call it —
+     `forge_commit({ entity:"{entity_kind}", id:"{record_id}", message:"<message>", trailer:"<line>" })`.
+     Never pass the message through a bash string when the typed tool exists.
+   - Otherwise (Claude Code): `node .forge/tools/commit-task.cjs --{entity_kind} {record_id} --message "<message>" [--trailer "<Co-authored-by line>"]`
+   - The tool owns the choreography: preflight gate (`preflight-gate.cjs --phase commit`
+     internally), status precondition (task `approved` / bug `in-progress` — wrong-state runs
+     halt with `× {record_id} is in state '{status}' …; /forge:approve must complete first`),
+     staging (artifact dir + `summaries.implementation.files_changed` provenance),
+     commit-boundary guard (aborts on a pre-staged index), `git commit`, terminal transition
+     (task → `committed`; bug → `fixed`, the ONLY post-triage `bug.status` write).
+   - On `no files_changed provenance` warning: ONE `git status --porcelain`, then re-run the
+     tool with `--also <path>` per source file. Never manual `git add`.
+   - Success → JSON with `ok:true`. `committed:true` carries `sha` + `staged`;
+     `committed:false, reason:"nothing-to-commit"` is ALSO success (fix already at HEAD /
+     staging set clean — the tool still sealed the record's terminal status). Do not
+     "fix" a no-op by staging things yourself.
+   - Failure (exit 1 / ok:false) → print stderr and HALT — no manual staging, no
+     `git reset`, no `--force` retry (operator-gated). Tool file missing → HALT;
+     instruct `/forge:update` + `/forge:rebuild tools`.
+   - NEVER commit before the tool reports `ok: true` — the premature-commit/reset/redo loop
+     is forbidden.
 
-3. Commit:
-   - Create a commit with a message following project conventions.
-   - Include the record ID in the commit message: task ID for task mode, bug ID for bug mode.
-   - Append a `Co-authored-by:` trailer crediting the AI assistant that actually ran the session. Resolve the identity from the host runtime: on Claude Code use `Co-authored-by: Claude <noreply@anthropic.com>`; on pi / Ollama / any other runtime use `Co-authored-by: {modelId} <noreply@{provider}.ai>` derived from the session's `provider` and `modelId` (e.g. `Co-authored-by: glm-5.1:cloud <noreply@ollama.ai>`); if neither is resolvable, omit the trailer rather than guess. Do NOT hardcode `Claude Opus 4.6 <noreply@anthropic.com>` — that literal is rejected as a regression of forge#82 (commits authored under the wrong model).
-   - Let git's configured `user.name` / `user.email` own the commit author; never pass `--author` to override it.
-
-4. Store Finalization:
-   - Transitions:
-     - **Task mode** — `approved → committed` (terminal): `node .forge/tools/store-cli.cjs update-status task {taskId} status committed`
-     - **Bug mode** — `in-progress → fixed` (terminal): `node .forge/tools/store-cli.cjs update-status bug {bugId} status fixed`. This is the ONLY phase in the bug pipeline that writes `bug.status` post-triage (see `meta-fix-bug.md § Iron Laws #2`). Do NOT write `approved` or `verified` — those values are vestigial enum members slated for removal.
-
-5. Finalize:
-   - **Do NOT emit a phase event yourself.** The orchestrator owns event emission — it composes the canonical event from runtime telemetry (model, provider, tokens, wall times) plus the SUMMARY you write in the next step. Subagents that call `store-cli emit` for phase events hallucinate runtime facts (see Plan 11 / Slice 2). Write the SUMMARY and return.
+4. Finalize:
+   - No summary, no `set-summary` (see Iron Laws). **Do NOT emit a phase event yourself** —
+     the orchestrator owns event emission. Return the tool's JSON result as your phase output.
 ```
 
 <!-- See _fragments/generation-instructions.md for Generation Instructions template -->

package/dist/forge-payload/.base-pack/workflows/implement_plan.md

@@ -83,13 +83,13 @@ deps:
          `node .forge/tools/store-cli.cjs update-status task {taskId} status implementing`
          `node .forge/tools/store-cli.cjs update-status task {taskId} status implemented`
      - **Bug mode** — NO status write. The bug remains `in-progress` until the commit phase transitions it to `fixed`. Writing `bug.status` here violates `meta-fix-bug.md § Iron Laws #2`.
-   - **Do NOT emit a phase event yourself.** The orchestrator owns event emission — it composes the canonical event from runtime telemetry (model, provider, tokens, wall times) plus the SUMMARY you write in the next step. Subagents that call `store-cli emit` for phase events hallucinate runtime facts (see Plan 11 / Slice 2). Write the SUMMARY and return.
+   - **Do NOT emit a phase event yourself.** The orchestrator owns event emission — it composes the canonical event from runtime telemetry plus the SUMMARY you write next. Subagents that call `store-cli emit` for phase events hallucinate runtime facts (Plan 11 / Slice 2). Write the SUMMARY and return.
 
 7. Emit Summary Sidecar:
    - Write `IMPLEMENTATION-SUMMARY.json` via `forge_artifact`:
      `forge_artifact({ command:"write", entity:"{entity_kind}", entityId:"{record_id}", artifact:"implementation-summary", content:"<JSON>" })`
-     JSON shape: `{"objective":"<one sentence>", "key_changes":["<up to 12 bullets>"], "verdict":"n/a", "written_at":"<ISO 8601>", "artifact_ref":"PROGRESS.md"}`
-     The tool validates required fields automatically — fix and retry if it rejects.
+     JSON shape: `{"objective":"<one sentence>", "key_changes":["<up to 12 bullets>"], "files_changed":["<path>"], "verdict":"n/a", "written_at":"<ISO 8601>", "artifact_ref":"PROGRESS.md"}`
+   - `files_changed`: every repo path this phase changed (one `git status --porcelain`); `commit-task.cjs` stages from it.
    - Then link sidecar to store (task mode):
      `forge_store({ command:"set-summary", args:["{taskId}", "implementation"] })`
      Or (bug mode):

package/dist/forge-payload/.base-pack/workflows-js/wfl-fix-bug.js

@@ -66,6 +66,22 @@ const SKIP_STATUS = ['blocked', 'escalated', 'fixed', 'abandoned']
 // non-review phase (the approve workflow self-escalates if it rejects).
 const REVIEW_ROLES = ['review-plan', 'review-code']
 
+// Bug-phase `type` tokens — verbatim port of the canonical table in
+// .forge/workflows/_fragments/event-vocabulary.md § Bug pipeline
+// (forge-engineering#39). The COMPLETE event carries the pass token (or the
+// fail token when a review phase's verdict is "revision"); the START event is
+// always untyped. Keyed by phase ROLE (matches PHASES_A/PHASES_B role names;
+// triage is keyed separately since it runs outside the phase loop).
+const BUG_TYPE_TOKENS = {
+  'triage':      { pass: 'bug-triaged',            fail: 'bug-triaged' },
+  'plan':        { pass: 'fix-planned',            fail: 'fix-planned' },
+  'review-plan': { pass: 'fix-review-passed',      fail: 'fix-review-failed' },
+  'implement':   { pass: 'fix-implemented',        fail: 'fix-implemented' },
+  'review-code': { pass: 'fix-code-review-passed', fail: 'fix-code-review-failed' },
+  'approve':     { pass: 'fix-approved',           fail: 'fix-revision-requested' },
+  'commit':      { pass: 'bug-committed',          fail: 'bug-commit-failed' },
+}
+
 // Per-phase model tier — verbatim port of fix_bug.md § Role-to-Tier Mapping.
 // Passed as the `model` opt to agent(); the host resolves the tier name to a model.
 const ROLE_TIER = {
@@ -160,6 +176,16 @@ function revisionTarget(phases, reviewIdx) {
 // The subagent owns ALL shell-dependent side-effects for this phase.
 function runBugPhase(bugId, phase, iter) {
   const sprintId = 'bugs'   // virtual sprint dir for all emit/sidecar/progress
+  // forge-engineering#39: explicit type-token guidance per
+  // .forge/workflows/_fragments/event-vocabulary.md § Bug pipeline. Without
+  // it, subagents guessed and leaked the action value into `type`
+  // ("start"/"complete" — schema-rejected store residue in events/bugs/).
+  const typeTokens = BUG_TYPE_TOKENS[phase.role]
+  const typeTokenLine = typeTokens
+    ? (REVIEW_ROLES.includes(phase.role)
+        ? 'set type="' + typeTokens.pass + '" when your verdict is Approved, type="' + typeTokens.fail + '" when it is Revision Required.'
+        : 'set type="' + typeTokens.pass + '".')
+    : 'omit the "type" field entirely (untyped events are valid; this role has no table entry).'
   return agent(
     [
       `You are running a SINGLE pipeline phase for Forge bug ${bugId} (sprint bugs).`,
@@ -175,11 +201,14 @@ function runBugPhase(bugId, phase, iter) {
       '   3a. BEFORE running the phase workflow: note the start timestamp (startTimestamp = new Date().toISOString()).',
       '   Emit a start event via `node .forge/tools/store-cli.cjs emit bugs \'{event-json}\'`',
       '   with action="start", role="' + phase.role + '", iteration=' + iter + ', startTimestamp and endTimestamp both equal to startTimestamp (0-duration placeholder).',
+      '   The start event MUST NOT include a "type" field.',
       '   3b. AFTER the phase workflow completes: note the end timestamp (endTimestamp = new Date().toISOString()).',
       '   Compute durationMinutes = (new Date(endTimestamp) - new Date(startTimestamp)) / 60000.',
       '   Emit a complete event via `node .forge/tools/store-cli.cjs emit bugs \'{event-json}\'`',
-      '   conforming to `.forge/schemas/event.schema.json` (role, action="complete", phase, iteration=' + iter + ',',
+      '   conforming to `.forge/schemas/event.schema.json` (role, action="complete", phase, iteration=' + iter + ', bugId,',
       '   startTimestamp, endTimestamp, durationMinutes, plus your own model/provider/token usage — do NOT invent placeholder model strings).',
+      '   COMPLETE-event type (per .forge/workflows/_fragments/event-vocabulary.md): ' + typeTokenLine,
+      '   NEVER copy the action value ("start"/"complete") into "type" — those tokens are schema-rejected and the event would be dropped.',
       '   If `/cost` data is available, also write the token sidecar via the `--sidecar` form. Best-effort; skip silently if unavailable.',
       '   Then drain any `.forge/cache/FRICTION-*.jsonl` friction records you produced and emit them as type "friction".',
       phase.role && REVIEW_ROLES.includes(phase.role)
@@ -230,14 +259,18 @@ const resolved = await agent(
 
 if (!resolved) throw new Error(`Could not resolve bug record for ${bugId}`)
 
-// Pre-loop status guard — fix_bug.md: skip at pre-loop with one bug_skipped event.
+// Pre-loop status guard — fix_bug.md: skip at pre-loop with one bug-skipped event.
+// Token + payload per _fragments/event-vocabulary.md (forge-engineering#39):
+// bug-skipped requires bugId but no phase/iteration; driver-emitted skips carry
+// model/provider "n/a"; the skip reason rides in "notes" (declared property).
 if (SKIP_STATUS.includes(resolved.bugStatus)) {
   log(`⚠ ${bugId} — status is ${resolved.bugStatus}, skipping run.`)
-  // Emit bug_skipped event (not a silent return — Iron Law 3).
+  // Emit bug-skipped event (not a silent return — Iron Law 3).
   await agent(
     [
-      `Emit a bug_skipped event for ${bugId}..`,
-      `Run \`node .forge/tools/store-cli.cjs emit bugs '{"type":"bug_skipped","sprintId":"bugs","bugId":"${bugId}","role":"orchestrator","action":"skipped","reason":"status=${resolved.bugStatus}","startTimestamp":"'$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)'","endTimestamp":"'$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)'","durationMinutes":0}'\`.`,
+      `Emit a bug-skipped event for ${bugId}.`,
+      `Run \`node .forge/tools/store-cli.cjs emit bugs '{"eventId":"<uuid-v4>","type":"bug-skipped","sprintId":"bugs","bugId":"${bugId}","role":"orchestrator","action":"skipped","notes":"status=${resolved.bugStatus}","startTimestamp":"'$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)'","endTimestamp":"'$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)'","durationMinutes":0,"model":"n/a","provider":"n/a"}'\`.`,
+      'Replace <uuid-v4> with a UUID v4 string (e.g. crypto.randomUUID()). Do NOT modify any other store records.',
       `Best-effort. Return taskStatus="${resolved.bugStatus}", gatePassed=true, verdict="none", escalated=false, phase="skip", role="orchestrator".`,
     ].join(' '),
     { label: `${bugId}:skip`, phase: 'Skip', schema: BUG_PHASE_RESULT_SCHEMA, model: 'haiku' }
@@ -268,11 +301,14 @@ let triageResult = await agent(
     '   3a. BEFORE running the triage workflow: note the start timestamp (startTimestamp = new Date().toISOString()).',
     '   Emit a start event via `node .forge/tools/store-cli.cjs emit bugs \'{event-json}\'`',
     '   with action="start", role="triage", iteration=1, startTimestamp and endTimestamp both equal to startTimestamp (0-duration placeholder).',
+    '   The start event MUST NOT include a "type" field.',
     '   3b. AFTER the triage workflow completes: note the end timestamp (endTimestamp = new Date().toISOString()).',
     '   Compute durationMinutes = (new Date(endTimestamp) - new Date(startTimestamp)) / 60000.',
     '   Emit a complete event via `node .forge/tools/store-cli.cjs emit bugs \'{event-json}\'`',
-    '   conforming to `.forge/schemas/event.schema.json` (role, action="complete", phase, iteration=1,',
+    '   conforming to `.forge/schemas/event.schema.json` (role, action="complete", phase, iteration=1, bugId,',
     '   startTimestamp, endTimestamp, durationMinutes, plus your own model/provider/token usage — do NOT invent placeholder model strings).',
+    '   COMPLETE-event type (per .forge/workflows/_fragments/event-vocabulary.md): set type="bug-triaged".',
+    '   NEVER copy the action value ("start"/"complete") into "type" — those tokens are schema-rejected and the event would be dropped.',
     '   If `/cost` data is available, also write the token sidecar via the `--sidecar` form. Best-effort; skip silently if unavailable.',
     '4. NON-REVIEW phase: return verdict="none".',
     '5. Read `.forge/store/bugs/' + bugId + '.json` and return its final status as taskStatus, plus a one-line note.',

package/dist/forge-payload/.base-pack/workflows-js/wfl-run-task.js

@@ -133,6 +133,22 @@ const SKIP_STATUS = ['blocked', 'escalated', 'committed', 'abandoned']
 // NOTE: `approve` is NOT here — orchestrate_task advances it on completion like a
 // non-review phase (the approve workflow self-escalates if it rejects).
 const REVIEW_ROLES = ['review-plan', 'review-code', 'validate']
+
+// Task-phase `type` tokens — verbatim port of the canonical table in
+// .forge/workflows/_fragments/event-vocabulary.md § Task pipeline
+// (forge-engineering#39). The COMPLETE event carries the pass token (or the
+// fail token when a review phase's verdict is "revision"); the START event is
+// always untyped. Roles outside this map emit untyped events (valid).
+const TASK_TYPE_TOKENS = {
+  'plan':        { pass: 'task-planned',     fail: 'task-planned' },
+  'review-plan': { pass: 'plan-approved',    fail: 'review-failed' },
+  'implement':   { pass: 'task-implemented', fail: 'task-implemented' },
+  'review-code': { pass: 'review-passed',    fail: 'review-failed' },
+  'validate':    { pass: 'task-validated',   fail: 'review-failed' },
+  'approve':     { pass: 'task-approved',    fail: 'review-failed' },
+  'commit':      { pass: 'task-committed',   fail: 'task-committed' },
+}
+
 // Per-phase model tier — verbatim port of orchestrate_task.md § Role-to-Tier Mapping.
 // The resolve agent uses this as a reference; JS loop calls resolveModel() not tierFor().
 const ROLE_TIER = {
@@ -338,17 +354,30 @@ function runPhase(taskId, sprintId, phase, iteration, { firstPhase = false, simp
   const eventIdLine = eventId
     ? '   Use eventId="' + eventId + '" for the COMPLETE event (the driver will call merge-sidecar with this id).'
     : '   Use a fresh crypto.randomUUID() for both start and complete event ids.'
+  // forge-engineering#39: explicit type-token guidance per
+  // .forge/workflows/_fragments/event-vocabulary.md. Without it, subagents
+  // guessed and leaked the action value into `type` ("start"/"complete" —
+  // schema-rejected store residue).
+  const typeTokens = TASK_TYPE_TOKENS[phase.role]
+  const typeTokenLine = typeTokens
+    ? (REVIEW_ROLES.includes(phase.role)
+        ? 'set type="' + typeTokens.pass + '" when your verdict is Approved, type="' + typeTokens.fail + '" when it is Revision Required.'
+        : 'set type="' + typeTokens.pass + '".')
+    : 'omit the "type" field entirely (untyped events are valid; this role has no table entry).'
   lines.push(
     '',
     '3. EMIT YOUR PHASE EVENTS. You are the only actor that knows your runtime attribution.',
     '   3a. BEFORE running the phase workflow: note the start timestamp (startTimestamp = new Date().toISOString()).',
     '   Emit a start event via `node .forge/tools/store-cli.cjs emit ' + sprintId + " '{event-json}'\`",
     '   with action="start", role="' + phase.role + '", iteration=' + iteration + ', startTimestamp and endTimestamp both equal to startTimestamp (0-duration placeholder).',
+    '   The start event MUST NOT include a "type" field.',
     '   3b. AFTER the phase workflow completes: note the end timestamp (endTimestamp = new Date().toISOString()).',
     '   Compute durationMinutes = (new Date(endTimestamp) - new Date(startTimestamp)) / 60000.',
     '   Emit a complete event via `node .forge/tools/store-cli.cjs emit ' + sprintId + " '{event-json}'\`",
     '   conforming to `.forge/schemas/event.schema.json` (role, action="complete", phase, iteration=' + iteration + ',',
     '   startTimestamp, endTimestamp, durationMinutes, plus your own model/provider/token usage — do NOT invent placeholder model strings).',
+    '   COMPLETE-event type (per .forge/workflows/_fragments/event-vocabulary.md): ' + typeTokenLine,
+    '   NEVER copy the action value ("start"/"complete") into "type" — those tokens are schema-rejected and the event would be dropped.',
     '   ' + eventIdLine,
     '   If `/cost` data is available, also write the token sidecar via the `--sidecar` form with the COMPLETE eventId. Best-effort; skip silently if unavailable.',
     '',
@@ -404,7 +433,9 @@ function emitSkip(taskId, sprintId, taskStatus) {
       `Emit a task_skipped event for Forge task ${taskId} (sprint ${sprintId}).`,
       `node .forge/tools/store-cli.cjs emit ${sprintId}`,
       `'{"type":"task-dispatch","action":"skip","taskId":"${taskId}","sprintId":"${sprintId}",`,
-      `"role":"orchestrator","phase":"pre-task","iteration":0,`,
+      // forge-engineering#39: iteration must be >= 1 (schema minimum) — the
+      // former zero value made every skip event silently schema-rejected.
+      `"role":"orchestrator","phase":"pre-task","iteration":1,`,
       `"notes":"pre-task SKIP_STATUS guard: task status is ${taskStatus}",`,
       `"startTimestamp":"<ISO-now>","endTimestamp":"<ISO-now>","durationMinutes":0,`,
       `"model":"<your-model-id>","provider":"anthropic"}'`,

package/dist/forge-payload/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "forge",
-  "version": "1.2.17",
+  "version": "1.2.21",
   "description": "Self-enhancing AI software development lifecycle — generates project-specific SDLC instances from meta-definitions",
   "license": "MIT",
   "author": {

package/dist/forge-payload/.schemas/enum-catalog.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.2.13",
-  "generated": "2026-06-03",
+  "version": "1.2.21",
+  "generated": "2026-06-06",
   "note": "Authoritative enum catalog. Source: build-enum-catalog.cjs. Regenerate via node forge/tools/build-manifest.cjs.",
   "enums": {
     "task.status": [

package/dist/forge-payload/.schemas/event.schema.json

@@ -59,11 +59,11 @@
         "sprint-complete",
         "sprint-halted",
         "task-dispatch",
-        "bug-fixed",
 
         "bug-triaged", "fix-planned", "fix-review-passed", "fix-review-failed",
         "fix-implemented", "fix-code-review-passed", "fix-code-review-failed",
-        "fix-approved", "bug-committed",
+        "fix-approved", "fix-revision-requested", "bug-committed",
+        "bug-commit-failed", "bug-skipped",
 
         "skill_usage"
       ]
@@ -129,7 +129,8 @@
             "enum": [
               "bug-triaged", "fix-planned", "fix-review-passed", "fix-review-failed",
               "fix-implemented", "fix-code-review-passed", "fix-code-review-failed",
-              "fix-approved", "bug-committed", "bug-fixed"
+              "fix-approved", "fix-revision-requested", "bug-committed",
+              "bug-commit-failed"
             ]
           }
         },
@@ -137,6 +138,10 @@
       },
       "then": { "required": ["bugId", "phase", "iteration"] }
     },
+    {
+      "if": { "properties": { "type": { "const": "bug-skipped" } }, "required": ["type"] },
+      "then": { "required": ["bugId"] }
+    },
     {
       "if": { "properties": { "type": { "const": "sprint-start" } }, "required": ["type"] },
       "then": {

package/dist/forge-payload/.schemas/migrations.json

@@ -1,4 +1,60 @@
 {
+  "1.2.20": {
+    "version": "1.2.21",
+    "date": "2026-06-06",
+    "notes": "commit-task.cjs hardening from its first live firing (HELLO-BUG-002 transcript analysis, forge-engineering#40). (1) Gitignored staging paths are pre-filtered with git check-ignore and warn-skipped — previously one ignored path aborted the all-or-nothing git add and the agent retried the identical command. (2) A clean staging set is now a legitimate no-op SUCCESS: the tool seals the record's terminal status and returns {ok:true, committed:false, reason:nothing-to-commit} — a bug whose fix is already at HEAD ends fixed without improvised manual transitions. Result JSON gains an explicit committed flag. meta-commit.md: forge_commit named tool is the primary surface on forgecli (typed args — no shell-quoting of the commit message); bash form stays as the Claude Code fallback; no-op outcome documented as success.",
+    "target": "tools:commit-task,workflows:commit_task",
+    "regenerate": [
+      "tools",
+      "workflows"
+    ],
+    "breaking": false,
+    "manual": [
+      "Run /forge:update, then /forge:rebuild tools workflows to refresh .forge/tools/commit-task.cjs and .forge/workflows/commit_task.md."
+    ]
+  },
+  "1.2.19": {
+    "version": "1.2.20",
+    "date": "2026-06-06",
+    "notes": "Deterministic commit choreography (forge-engineering#40). The commit phase was the most expensive phase of the pipeline (15-31% of run input tokens) because an LLM re-derived deterministic choreography turn-by-turn. New tools/commit-task.cjs owns the whole sequence — preflight gate, status precondition, staging-set derivation (record artifact dir + implementation file provenance), commit-boundary guard (aborts on a pre-populated index), git commit, terminal status transition (task→committed / bug→fixed) — with --dry-run, argv-array spawns, and operator-gated --force. The implement phase now records files_changed provenance in IMPLEMENTATION-SUMMARY.json (new optional PHASE_SUMMARY_SCHEMA key, max 100 paths) so commit never re-derives the change surface from git. meta-commit.md rewritten: agent inspects once (git diff --stat), crafts the message, calls the tool once; explicit no-summary contract (commit is not in VALID_SUMMARY_PHASES — the previous prompt commanded writing a SUMMARY that the schema rejects, sending agents on an unwinnable format hunt plus 3 write-verification retries); batched-inspection rule; commit-early/reset/redo loop forbidden.",
+    "target": "tools:commit-task,tools:store-cli,workflows:commit_task,workflows:implement_plan",
+    "regenerate": [
+      "tools",
+      "workflows"
+    ],
+    "breaking": false,
+    "manual": [
+      "Run /forge:update, then /forge:rebuild tools workflows to vendor .forge/tools/commit-task.cjs and refresh .forge/workflows/commit_task.md + implement_plan.md. Until the rebuild, the regenerated commit workflow will reference a tool that is not yet vendored and will halt loudly (by design)."
+    ]
+  },
+  "1.2.18": {
+    "version": "1.2.19",
+    "date": "2026-06-06",
+    "notes": "Event-type discipline in the JS workflow drivers (forge-engineering#39 Phase 3). wfl-run-task.js and wfl-fix-bug.js now carry TASK_TYPE_TOKENS / BUG_TYPE_TOKENS maps (verbatim ports of _fragments/event-vocabulary.md) and inject explicit per-phase type guidance into the subagent emit instructions: start events MUST NOT carry a type field, complete events set the exact pass/fail token for the phase, and copying the action value (start/complete) into type is explicitly forbidden — that guess-leak was the source of the schema-rejected type:start/type:complete store residue. Also fixes wfl-run-task emitSkip(): the skip event emitted iteration 0, violating the schema's minimum of 1, so every pre-task skip event was silently rejected; now 1.",
+    "target": "workflows-js:wfl-run-task,workflows-js:wfl-fix-bug",
+    "regenerate": [
+      "workflows-js"
+    ],
+    "breaking": false,
+    "manual": [
+      "Run /forge:update, then /forge:rebuild to regenerate .claude/workflows/wfl-run-task.js and wfl-fix-bug.js from the base-pack. Prompt/instruction text + one literal fix — no schema or tool change."
+    ]
+  },
+  "1.2.17": {
+    "version": "1.2.18",
+    "date": "2026-06-06",
+    "notes": "Event-type vocabulary gets a spec owner (forge-engineering#39). New canonical fragment _fragments/event-vocabulary.md defines the phase→type token tables for task/bug/sprint events; schemas/event.schema.json now mirrors it: adds the bug-pipeline fail tokens fix-revision-requested (approve) and bug-commit-failed (commit) that forge-cli already emits (previously rejected by the enum — events and their token telemetry were silently dropped), adds bug-skipped (pre-loop skip; requires bugId, no phase/iteration), and retires bug-fixed (defined, emitted by nothing, zero store occurrences). The wfl-fix-bug.js base-pack driver's skip emit was triple-broken against the schema (underscore bug_skipped token, missing required eventId/model/provider, undeclared reason key) — now emits a valid bug-skipped event with the skip reason in notes and model/provider \"n/a\". meta-fix-bug.md and meta-orchestrate.md reference the vocabulary fragment; emitted tokens MUST come from its tables.",
+    "target": "schemas:event,fragments:event-vocabulary,fragments:event-emission-schema,workflows:fix_bug,workflows:orchestrate_task,workflows-js:wfl-fix-bug",
+    "regenerate": [
+      "schemas",
+      "workflows",
+      "workflows-js"
+    ],
+    "breaking": false,
+    "manual": [
+      "Run /forge:update, then /forge:rebuild schemas workflows to refresh .forge/schemas/event.schema.json, .forge/workflows/ (fix_bug.md, orchestrate_task.md, _fragments/), and the regenerated .claude/workflows/wfl-fix-bug.js. Projects with the legacy invalid store events (type start/complete/feature_implemented) can clear them via /forge:repair — strip the invalid type field (untyped events are valid)."
+    ]
+  },
   "1.2.16": {
     "version": "1.2.17",
     "date": "2026-06-04",

package/dist/forge-payload/integrity.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.2.14",
-  "generated": "2026-06-03",
+  "version": "1.2.21",
+  "generated": "2026-06-06",
   "note": "Tamper-evident only. Authoritative source: /forge:update from remote.",
   "files": {
     "commands/add-pipeline.md": "529a2fc01be49815efa2cf1147528827ff1bfc12ce2ac8663b5a3a9781f8682e",
@@ -30,7 +30,7 @@
     "schemas/transitions/bug.json": "27b17da42d1cebffbd4f61ab3dcd432a0017aa71997d548ed80d22c2fc3fad6a",
     "schemas/transitions/sprint.json": "2e0a629396e687b0ca88e1814ac3e35d84533a5d55b25237ab67feddce3c9deb",
     "schemas/transitions/task.json": "4c71849747baa0d585756e57c56325ff6219c078178374e60815dff91e25e3e7",
-    "schemas/enum-catalog.json": "14fa6c470292fb433a4e33503669f567bd53e3851b25000c05ddca0fdfdd6e58",
+    "schemas/enum-catalog.json": "68260bed8e6fe347bc4a1c870fa1ea51ca1ebc45873aae929624837afe8f0bdb",
     "tools/verify-integrity.cjs": "3ec3c970dd3d7c3001f8f373bcc40556803eadd2fc2afafb14f1c232cba4cc3f"
   }
 }

package/dist/forge-payload/meta/store-schema/event.schema.md

@@ -10,6 +10,13 @@
 
 Example: `20260415T141523000Z_ACME-S02-T03_engineer_implement`
 
+## Type Vocabulary
+
+The optional `type` field, when present, must come from the canonical
+phase→type tables in `meta/workflows/_fragments/event-vocabulary.md`
+(task / bug / sprint / friction / skill_usage families). The schema enum in
+`schemas/event.schema.json` mirrors that fragment.
+
 ## Fields
 
 | Field | Type | Required | Description |

package/dist/forge-payload/meta/workflows/_fragments/event-emission-schema.md

@@ -4,6 +4,10 @@
      orchestrator stitches runtime telemetry + judgement into the canonical
      event and emits it. Referenced by meta-orchestrate.md and meta-fix-bug.md.
 
+     Companion: _fragments/event-vocabulary.md owns the `type` token
+     vocabulary (phase→type tables for task/bug/sprint events). This fragment
+     owns WHO emits; that one owns WHAT token.
+
      PLAN-11 / SLICE-2 (2026-05-14): the LLM no longer hand-builds event JSON.
      Runtime facts (model, provider, eventId, timestamps, iteration, tokens)
      are owned by the orchestrator, never the subagent. The subagent only

package/dist/forge-payload/meta/workflows/_fragments/event-vocabulary.md

@@ -0,0 +1,88 @@
+# Fragment: Event Type Vocabulary
+
+<!-- Canonical phase→type vocabulary for store events (forge-engineering#39).
+     This fragment OWNS the `type` token vocabulary; `schemas/event.schema.json`
+     mirrors it. Any vocabulary change lands here first, then in the schema enum
+     (test-first via tools/__tests__/event-schema-variants.test.cjs), then in
+     emitters (forge-cli orchestrators, wfl JS drivers, meta workflows).
+
+     Companion: _fragments/event-emission-schema.md owns WHO emits (orchestrator
+     vs subagent field ownership). This fragment owns WHAT token each phase emits.
+
+     Invariant: every token emitted by any surface MUST appear in the schema
+     enum, and every enum token MUST have a named emitter below. Dead tokens are
+     removed (bug-fixed was retired by forge-engineering#39 — defined, never
+     emitted by anything). -->
+
+## Rules
+
+1. **Emitted tokens ⊆ schema enum.** An emitter never invents a token. If a new
+   phase outcome needs a token, add it here + the schema enum first.
+2. **`type` is optional** on events. An untyped event is valid (task-pipeline
+   events from forge-cli run-task are currently untyped). When a `type` IS set,
+   it must come from the tables below.
+3. **Kebab-case for lifecycle tokens.** Underscore names are reserved for the
+   `friction` and `skill_usage` event families.
+4. **Conditional fields.** Typed events trigger schema conditionals — see the
+   "Requires" column. Driver-emitted skip events have no model/provider; emit
+   the literal `"n/a"` for both (never guess a model string — see
+   `_fragments/event-emission-schema.md` §Why no example record here).
+5. **Skip reasons ride in `notes`.** `reason` is not a declared event property
+   (`additionalProperties: false` rejects it).
+
+## Task pipeline (orchestrate_task / run-task / wfl:run-task)
+
+| Phase | Pass token | Fail token | Requires |
+|---|---|---|---|
+| plan | `task-planned` | `task-planned` | taskId, phase, iteration |
+| review-plan | `plan-approved` | `review-failed` | taskId, phase, iteration |
+| implement | `task-implemented` | `task-implemented` | taskId, phase, iteration |
+| review-code | `review-passed` | `review-failed` | taskId, phase, iteration |
+| validate | `task-validated` | `review-failed` | taskId, phase, iteration |
+| approve | `task-approved` | `review-failed` | taskId, phase, iteration |
+| commit | `task-committed` | `task-committed` | taskId, phase, iteration |
+
+`plan-complete` is a legacy alias accepted by the enum for plan-phase events;
+new emitters use `task-planned`.
+
+## Bug pipeline (fix_bug / fix-bug / wfl:fix-bug)
+
+| Phase | Pass token | Fail token | Requires |
+|---|---|---|---|
+| pre-loop skip | `bug-skipped` | — | bugId (no phase/iteration; model/provider `"n/a"`) |
+| triage | `bug-triaged` | `bug-triaged` | bugId, phase, iteration |
+| plan-fix | `fix-planned` | `fix-planned` | bugId, phase, iteration |
+| review-plan | `fix-review-passed` | `fix-review-failed` | bugId, phase, iteration |
+| implement | `fix-implemented` | `fix-implemented` | bugId, phase, iteration |
+| review-code | `fix-code-review-passed` | `fix-code-review-failed` | bugId, phase, iteration |
+| approve | `fix-approved` | `fix-revision-requested` | bugId, phase, iteration |
+| commit | `bug-committed` | `bug-commit-failed` | bugId, phase, iteration |
+
+Non-review phases emit their single token regardless of outcome (the verdict
+field carries the judgement); review phases (review-plan, review-code, approve)
+select pass/fail on `verdict == "revision"`.
+
+## Sprint grain (run_sprint / run-sprint / wfl:run-sprint)
+
+| Moment | Token | Requires |
+|---|---|---|
+| before wave loop | `sprint-start` | sprintId (taskCount optional) |
+| before each task dispatch | `task-dispatch` | taskId (convention; phase/iteration carried but not schema-enforced) |
+| sprint finished | `sprint-complete` | taskCount, completedTaskIds, verdict |
+| sprint aborted | `sprint-halted` | haltedAtTaskIndex, haltedAtTaskId, lastError |
+
+## Other families
+
+| Token | Emitter | Spec |
+|---|---|---|
+| `friction` | any persona, drained by orchestrator | `_fragments/friction-emit.md` |
+| `skill_usage` | forge-cli skill-curation telemetry | `event.schema.json` skill_usage conditional |
+
+## Out of scope (known follow-ups)
+
+- **Feature events** have no lifecycle tokens; feature-related events are
+  emitted untyped. Defining a feature vocabulary is a future change to this
+  fragment + the enum.
+- **Task-pipeline typed emission in forge-cli** — run-task currently emits
+  untyped events (valid under Rule 2); adopting the task table above is
+  forward work tracked in forge-engineering#39 step 3.