@entelligentsia/forgecli 1.0.2 → 1.0.10

package/dist/forge-payload/.base-pack/workflows/_fragments/store-cli-verbs.md

@@ -32,14 +32,29 @@ Notes for subagents:
   The three-arg form `update-status task {taskId} {value}` is WRONG and will
   error. Always include `status` between the id and the value.
 - **`emit`** appends an event. There is no `append-event` / `add-event`.
-- **`set-summary`** / **`set-bug-summary`** write summary sidecars referenced
-  from the entity record. Do not inline summaries into the entity via `write`.
+- **`set-summary <id> <phase>`** / **`set-bug-summary <id> <phase>`** link a
+  phase summary onto the entity record. The JSON-file argument is **optional**:
+  when omitted, the sidecar is auto-resolved from the record's `path` plus the
+  canonical phase→filename map (so `set-summary {taskId} validation` just works).
+  Never pass a hand-built `engineering/sprints/.../…-SUMMARY.json` path. Do not
+  inline summaries into the entity via `write`.
 - **Artifact I/O:** Use `forge_artifact` for ALL phase artifact reads and writes
   (PLAN.md, PROGRESS.md, *-SUMMARY.json, CODE_REVIEW.md, etc.). Never construct
   artifact file paths manually — the tool resolves paths from entity IDs and
   validates JSON summary schemas on write. After writing a summary JSON via
-  `forge_artifact`, link it to the store record via `forge_store set-summary`.
+  `forge_artifact`, link it to the store record via `forge_store set-summary {id} {phase}` (no path).
   Example: `forge_artifact({ command:"write", entity:"task", entityId:"{taskId}", artifact:"progress", content:"..." })`
+- **Artifact addressing (canonical) — never reconstruct a path.** Address an
+  artifact by `(entity, entityId, kind)` via `forge_artifact`, or read the
+  entity's `path` field from the store record. The on-disk directory is owned by
+  the record's `path`, NOT by any id template. Token glossary:
+  - `{sprintId}` / `{taskId}` / `{bugId}` — the **store record filenames**
+    (`.forge/store/<kind>s/<id>.json`); deterministic and safe to use as IDs.
+  - `{sprint}` / `{task}` / `{bug}` — runtime path-template substitutions used by
+    the **preflight gate**, derived from the record's `path` (not the bare ID).
+  - The engineering artifact directory always comes from `record.path`.
+  These spellings are parsed literally by tools (`preflight-gate.cjs`,
+  `collate.cjs`) — do not invent new spellings or rename them in prose.
 - If you need a verb not on this list, run
   `node "$FORGE_ROOT/tools/store-cli.cjs" --help` before improvising.
 - If you supply an unknown verb, entity type, enum value, or field name,

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

@@ -98,15 +98,14 @@ deps:
        "artifact_ref":"ARCHITECT_APPROVAL.md"
      }
      ```
-   - Call (task mode) — optional for tasks, since `task.status` is the canonical signal:
+   - Call (task mode) — optional for tasks, since `task.status` is the canonical signal.
+     The sidecar path is auto-resolved from the record's `path` — never pass it:
      ```
-     node "$FORGE_ROOT/tools/store-cli.cjs" set-summary {taskId} approve \
-       engineering/sprints/{sprint}/{task}/APPROVE-SUMMARY.json
+     node "$FORGE_ROOT/tools/store-cli.cjs" set-summary {taskId} approve
      ```
      Or (bug mode) — REQUIRED for bugs, this is the canonical verdict signal:
      ```
-     node "$FORGE_ROOT/tools/store-cli.cjs" set-bug-summary {bugId} approve \
-       engineering/bugs/{bugDir}/APPROVE-SUMMARY.json
+     node "$FORGE_ROOT/tools/store-cli.cjs" set-bug-summary {bugId} approve
      ```
    - In bug mode, if the set-bug-summary call exits non-zero, fix the sidecar JSON and retry. Do not return without a valid summary — the downstream commit gate has no other way to read the approval verdict.
 ```

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

@@ -67,7 +67,7 @@ Never set `FORGE_SKIP_WRITE_VALIDATION=1` — operator-only emergency switch.
 
 4. Finalize:
    - **Do NOT emit a phase event yourself.** The orchestrator (or kickoff handler) 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.
-   - Write `WRITEBACK-SUMMARY.json` to the sprint directory (`engineering/sprints/{sprintId}/`) with the following shape:
+   - Write `WRITEBACK-SUMMARY.json` to the sprint's artifact directory — use the sprint record's `path` field (read it from the store), not a reconstructed `engineering/sprints/{sprintId}/` template — with the following shape:
      ```json
      {
        "objective":   "<one sentence — what views were regenerated>",

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

@@ -57,9 +57,8 @@ deps:
 
 1. Load Context:
    - Read the record manifest (task or bug, per entity_kind).
-   - Read ARCHITECT_APPROVAL.md from the record's artifact directory:
-     - Task mode: `engineering/sprints/{sprint}/{task}/ARCHITECT_APPROVAL.md`
-     - Bug mode:  `engineering/bugs/{bugDir}/ARCHITECT_APPROVAL.md`
+   - Read ARCHITECT_APPROVAL.md by kind — never construct the path:
+     `forge_artifact({ command:"read", entity:"{entity_kind}", entityId:"{record_id}", artifact:"architect-approval" })`
 
 2. Staging:
    - Stage all record-related artifacts and the code changes:

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

@@ -23,7 +23,7 @@ Phases`):
 
 | Phase | Role | Persona | Workflow | Path A | Path B |
 |---|---|---|---|---|---|
-| triage | `triage` | bug-fixer | (inline algorithm) | yes | yes |
+| triage | `triage` | bug-fixer | `triage.md` | yes | yes |
 | plan-fix | `plan` | engineer | `plan_task.md` (bug-mode) | no | yes |
 | review-plan | `review-plan` | supervisor | `review_plan.md` | no | yes |
 | implement | `implement` | engineer | `implement_plan.md` (bug-mode) | yes | yes |
@@ -93,24 +93,11 @@ The `route` field is required. Allowed values: `"A"` or `"B"`.
 > Triage subagents MUST NOT touch `bug.path` — that field is set at bug
 > creation and never modified by triage.
 
-### Path A — short-circuit (eligibility)
+### Path A / Path B eligibility
 
-Path A is **eligible only when ALL** of the following hold. Triage subagent
-must enumerate each in its findings:
-
-- `bug.severity ∈ {minor}`
-- Fix is contained in a single file
-- Estimated diff ≤ ~20 lines (judgement call; one screen)
-- No schema, API, migration, security, or build-system change
-- A regression test is obvious from the reproduction script (single short
-  test case, no new fixtures, no test-harness change)
-
-If any criterion fails, the triage subagent MUST select Path B.
-
-### Path B — full loop (default)
-
-Path B runs the same plan/review/implement/review/approve/commit shape as
-`meta-orchestrate.md`. It is the default. Any uncertainty defaults Path B.
+See `triage.md § Path A / Path B Eligibility` for the criteria the triage
+subagent applies. The criteria are single-sourced in the triage workflow;
+this orchestrator only reads the resulting `summaries.triage.route` value.
 
 ### Pipeline selection by path
 
@@ -156,16 +143,11 @@ Differences are confined to the **triage** step and the **path branch**.
      b. If .forge/store/bugs/{BUG_ID}.json does NOT exist, write a fresh record
         via store-cli with status="reported".
      c. Read the now-guaranteed record.
-   - Spawn the triage subagent (persona: bug-fixer). It MUST:
-     • Reproduce the bug (failing test or reproduction script).
-     • Confirm the root cause via codebase research.
-     • Decide Path A vs Path B by the criteria above.
-     • Write triage artifact:
-       forge_artifact({ command:"write", entity:"bug", entityId:"{bugId}", artifact:"triage", content:"<markdown>" })
-     • Write triage-summary artifact (JSON shape documented in § Triage Judgement):
-       forge_artifact({ command:"write", entity:"bug", entityId:"{bugId}", artifact:"triage-summary", content:"<JSON>" })
-     • Call set-bug-summary {bugId} triage via forge_store:
-       forge_store({ command:"set-bug-summary", bugId:"{bugId}", phase:"triage", file:"TRIAGE-SUMMARY.json" })
+   - Spawn the triage subagent (workflow: `triage.md`, persona: bug-fixer).
+     It MUST write `TRIAGE.md` + `TRIAGE-SUMMARY.json` with a `route` field
+     (`"A"` or `"B"`) and call `set-bug-summary {bugId} triage` per
+     `triage.md`. The triage workflow is `audience: subagent`, `phase: triage`;
+     the orchestrator MUST NOT pass any other workflow body to this subagent.
    - On return, orchestrator transitions status:
        store-cli update-status bug {bugId} status triaged
        store-cli update-status bug {bugId} status in-progress

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

@@ -92,9 +92,10 @@ deps:
      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.
    - Then link sidecar to store (task mode):
-     `forge_store({ command:"set-summary", args:["{taskId}", "implementation", "engineering/sprints/{sprint}/{task}/IMPLEMENTATION-SUMMARY.json"] })`
+     `forge_store({ command:"set-summary", args:["{taskId}", "implementation"] })`
      Or (bug mode):
-     `forge_store({ command:"set-bug-summary", args:["{bugId}", "implementation", "engineering/bugs/{bugDir}/IMPLEMENTATION-SUMMARY.json"] })`
+     `forge_store({ command:"set-bug-summary", args:["{bugId}", "implementation"] })`
+     The sidecar path is auto-resolved from the record's `path` — never pass it.
 ```
 
 <!-- See _fragments/iron-laws.md for Iron Laws section structure guidance -->

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

@@ -561,28 +561,32 @@ for each task in dependency_sorted(tasks):
       /compact
       continue
 
-    # --- Review phase: detect verdict via parse-verdict.cjs (see Verdict Detection below) ---
-    # The CLI returns exit 0/1/2 for approved/revision/unknown. Never pattern-match
-    # the **Verdict:** line manually — the closed vocabulary lives in the tool.
+    # --- Review phase: detect verdict via read-verdict.cjs (see Verdict Detection below) ---
+    # Verdicts come from the STORE record (phase summaries / task.status), NOT from a
+    # markdown review artifact — the orchestrator never constructs an artifact path.
+    # stdout is one of: approved | revision | n/a | unknown. Never pattern-match a
+    # **Verdict:** line — the closed vocabulary lives in the tool.
     verdict_result = run_bash(
-      f'node "$FORGE_ROOT/tools/parse-verdict.cjs" {review_artifact_path(phase, task)}'
+      f'node "$FORGE_ROOT/tools/read-verdict.cjs" --phase {phase.role} --task {task_id}'
     )
-    if verdict_result.exit_code == 0:
+    verdict_token = verdict_result.stdout.strip()
+    if verdict_token == "approved":
       verdict = "Approved"
-    elif verdict_result.exit_code == 1:
+    elif verdict_token == "revision":
       verdict = "Revision Required"
     else:
-      # exit 2: malformed, missing verdict line, or missing artifact. Never guess.
+      # "n/a" / "unknown" (no verdict recorded) or exit 2 (record not found / bad args).
+      # Never guess.
       print(f"  ⚠ {task_id}  {phase.role}  — verdict_malformed, escalating\n")
       emit_event(task, phase, action="verdict_malformed",
-                 notes=f"parse-verdict exit={verdict_result.exit_code}")
+                 notes=f"read-verdict stdout='{verdict_token}' exit={verdict_result.exit_code}")
       # ---- ESCALATION (mandatory hard stop — do NOT continue) ----
       run_bash(f'node "$FORGE_ROOT/tools/store-cli.cjs" update-status task {task_id} status escalated')
       emit_event(task, phase, eventId=event_id, iteration=iteration,
                  action="escalated", verdict="escalated",
-                 notes="verdict_malformed: review artifact missing or verdict line unparseable")
-      print(f"  ⚠ Task {task_id} escalated: verdict_malformed — review artifact missing or verdict line unparseable\n")
-      print(f"  Review artifact: {review_artifact_path(phase, task)}\n")
+                 notes="verdict_malformed: no verdict recorded in the phase summary / record")
+      print(f"  ⚠ Task {task_id} escalated: verdict_malformed — no verdict recorded for {phase.role}\n")
+      print(f"  Inspect with: node \"$FORGE_ROOT/tools/read-verdict.cjs\" --phase {phase.role} --task {task_id}\n")
       print(f"  Resume with: /{phase.command} {task_id} after addressing the issues.\n")
       break
 
@@ -604,7 +608,7 @@ for each task in dependency_sorted(tasks):
                    action="escalated", verdict="escalated",
                    notes="max iterations reached")
         print(f"  ⚠ Task {task_id} escalated: max iterations reached\n")
-        print(f"  Review artifact: {review_artifact_path(phase, task)}\n")
+        print(f"  Inspect with: node \"$FORGE_ROOT/tools/read-verdict.cjs\" --phase {phase.role} --task {task_id}\n")
         print(f"  Resume with: /{phase.command} {task_id} after addressing the issues.\n")
         break
         break                               # stop processing this task
@@ -616,7 +620,7 @@ for each task in dependency_sorted(tasks):
       print(f"[checkpoint] task={task_id} sprint={sprint_id} phase_index={i} iterations={iteration_counts}")
       /compact
 
-    # No `else:` branch needed — parse-verdict.cjs already exhausts the
+    # No `else:` branch needed — read-verdict.cjs already exhausts the
     # possibilities (approved | revision | verdict_malformed), and the
     # malformed case is handled above before this if/elif chain.
 ```
@@ -676,45 +680,35 @@ Examples:
 ## Verdict Detection
 
 After each review phase completes, the orchestrator MUST read the verdict
-before branching. Do not infer the verdict from conversation context alone —
-always read the artifact.
+before branching. Do not infer the verdict from conversation context alone, and
+**never construct or read a markdown artifact path** to find it — the verdict
+lives in the **store record** (the phase summary written by `set-summary`, or
+`task.status` for the approve phase).
 
-| Phase role    | Artifact to read                                                          | Verdict field                |
-|---------------|---------------------------------------------------------------------------|------------------------------|
-| `review-plan` | `{engineering}/sprints/{sprintDir}/{taskDir}/PLAN_REVIEW.md`              | Line matching `**Verdict:**` |
-| `review-code` | `{engineering}/sprints/{sprintDir}/{taskDir}/CODE_REVIEW.md`              | Line matching `**Verdict:**` |
-| `validate`    | `{engineering}/sprints/{sprintDir}/{taskDir}/VALIDATION_REPORT.md`        | Line matching `**Verdict:**` |
-
-The verdict line format is:
-
-```
-**Verdict:** Approved
-```
-or
-```
-**Verdict:** Revision Required
-```
-
-**Parse the verdict via `parse-verdict.cjs`** — do NOT pattern-match the
-line manually. The tool enforces a closed verdict vocabulary so typos, case
-drift, and reviewer prose cannot cause silent misclassification:
+**Read the verdict via `read-verdict.cjs`** — addressed by entity ID and phase
+role, never by file path. The tool sources the verdict from the record and
+enforces a closed vocabulary so typos, case drift, and reviewer prose cannot
+cause silent misclassification:
 
 ```
 FORGE_ROOT = resolve_forge_root()
-result = run_bash(f'node "$FORGE_ROOT/tools/parse-verdict.cjs" {artifact_path}')
-# exit 0 → approved   (stdout "approved")
-# exit 1 → revision   (stdout "revision")
-# exit 2 → unknown/malformed/missing (stdout "unknown")
+result = run_bash(f'node "$FORGE_ROOT/tools/read-verdict.cjs" --phase {phase.role} --task {task_id}')
+# stdout "approved" → approved
+# stdout "revision" → revision
+# stdout "n/a" | "unknown" → no verdict recorded (treat as malformed; do NOT guess)
+# exit 2 → record not found / invalid args (treat as malformed)
 ```
 
-Recognised values (case-insensitive):
+Branch on the **stdout token** (exit 1 bundles both `revision` and the
+no-verdict cases, so the token is authoritative). Recognised verdict values:
 
-- **approved** — `Approved`, `Approve`, `[Approved]`
-- **revision** — `Revision Required`, `Revision`, `Needs Revision`, `Changes Requested`
+- **approved** — written as `verdict: "approved"` in the phase summary (or `task.status == approved` for the approve phase).
+- **revision** — `verdict: "revision"`.
 
-Anything else — including free-form prose, missing bold markers, a missing
-verdict line, or a missing artifact — yields exit 2. Do NOT treat unknown
-as approved or revision; halt the loop and escalate via `verdict_malformed`.
+Anything else — `n/a`, `unknown`, a missing summary, or a missing record —
+must NOT be treated as approved or revision; halt the loop and escalate via
+`verdict_malformed`. (In bug mode pass `--bug {bug_id}`; `read-verdict.cjs`
+applies the bug-specific phase→summary map.)
 
 ## Escalation Procedure
 
@@ -750,8 +744,8 @@ Grammar (one directive per line):
   `in [v1, v2, ...]`. Fields are dotted paths against the store record, e.g.
   `task.status`.
 - `forbid <field> <op> <value>` — predicate must NOT hold.
-- `after <phase> = <approved|revision>` — predecessor phase's review artifact
-  must carry the stated verdict (parsed by `parse-verdict.cjs`).
+- `after <phase> = <approved|revision>` — predecessor phase's stored verdict
+  must match (read from the record by `read-verdict.cjs`, not from markdown).
 
 ```gates phase=plan
 forbid task.status == committed
@@ -849,7 +843,7 @@ is a violation of the Iron Laws.
 - Subagent empty/crash/timeout response: retry once with simplified prompt
   (strip summary and architecture blocks). Escalate on second failure.
   See Subagent Response Validation in the Execution Algorithm.
-- Subagent non-zero exit code (not parse-verdict): same as above — retry
+- Subagent non-zero exit code (not read-verdict): same as above — retry
   once, escalate on second failure. The crash reason is captured in the
   escalation event notes.
 - Verdict malformed or missing: escalate to human immediately. Never guess.

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

@@ -0,0 +1,190 @@
+---
+requirements:
+  reasoning: High
+  context: Medium
+  speed: Medium
+audience: subagent
+phase: triage
+context:
+  architecture: false
+  prior_summaries: delta
+  persona: summary
+  master_index: false
+  diff_mode: false
+deps:
+  personas: [bug-fixer]
+  skills: [bug-fixer, generic]
+  templates: []
+  sub_workflows: []
+  kb_docs: [architecture/stack.md]
+  config_fields: [commands.test, paths.engineering]
+---
+
+
+# Bug Triage
+## Iron Laws
+
+- Reproduce the bug before deciding anything. A bug without a confirmed
+  reproduction has no business going to plan-fix or implement.
+- Read `.forge/personas/bug-fixer.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_ROOT/tools/store-cli.cjs"`).
+  Never edit `.forge/store/*.json` directly.
+- **Triage NEVER writes `bug.status`.** The orchestrator (`meta-fix-bug.md`)
+  owns the `reported → triaged` and `triaged → in-progress` transitions.
+  Writing `bug.status` from this workflow violates `meta-fix-bug.md
+  § Iron Laws #2` (parallel to `meta-review-plan.md`'s "Supervisor NEVER
+  writes entity status" rule).
+- Triage is a **single phase**. Do NOT call `forge_preflight` with any
+  other `--phase` value. Do NOT call `forge_store update-status`,
+  `set-bug-summary` for any non-triage phase, or `forge_store emit`.
+  These are orchestrator-owned or other-phase-owned actions. The
+  phase-ownership guard in forge-cli will reject violations at the tool
+  layer, but the Iron Law names the rule.
+
+## Store-Write Verification
+
+<!-- See _fragments/store-write-verification.md for the canonical block content -->
+
+## Algorithm
+
+```
+
+0. Pre-flight Gate Check:
+   - Resolve FORGE_ROOT (`node -e "console.log(require('./.forge/config.json').paths.forgeRoot)"`).
+   - Run: `node "$FORGE_ROOT/tools/preflight-gate.cjs" --phase triage --bug {bugId}`
+   - Exit 1 (gate failed) → print stderr and HALT. Do not proceed.
+   - Exit 2 (misconfiguration) → print stderr and HALT.
+   - Exit 0 → continue.
+
+1. Load Context:
+   - Read `.forge/personas/bug-fixer.md` first; print the persona identity
+     line to stdout before any other tool use.
+   - Read the bug record:
+     `forge_store({ command:"read", entity:"bug", id:"{bugId}" })`
+   - Read business domain docs relevant to the reported symptom.
+   - store-cli verbs: `read` | `list` | `write` | `emit` |
+     `update-status` | `set-summary` | `set-bug-summary` | `describe` |
+     `nlp` | `query` | `delete` — there is no `get`/`set`/`find`. See
+     `_fragments/store-cli-verbs.md` for full notes.
+
+2. Reproduce:
+   - Construct a minimal reproduction: a failing test, a short script,
+     or a documented manual sequence that triggers the reported symptom.
+   - If reproduction cannot be achieved with the information in the bug
+     record, write what was tried in TRIAGE.md, set the route to "B"
+     (any uncertainty defaults to Path B), and continue to root-cause
+     research with the reporter's narrative as the working hypothesis.
+
+3. Root-Cause Research:
+   - Read the code paths implicated by the reproduction.
+   - Confirm (or revise) the reporter's stated root cause via direct
+     inspection of source files and tests.
+   - Note collateral damage: which other call sites, schemas, or
+     workflows share the defective shape.
+
+4. Path A / Path B Eligibility:
+   - Apply the criteria in § "Path A / Path B Eligibility" below.
+   - Record the route decision and the explicit enumeration of each
+     criterion in the findings section of the triage summary.
+
+5. Write Triage Artifacts:
+   - Write the triage artifact (markdown narrative):
+     `forge_artifact({ command:"write", entity:"bug", entityId:"{bugId}",
+                       artifact:"triage", content:"<markdown>" })`
+   - Write the triage-summary sidecar (JSON shape below):
+     `forge_artifact({ command:"write", entity:"bug", entityId:"{bugId}",
+                       artifact:"triage-summary", content:"<JSON>" })`
+
+6. Finalize:
+   - **No status write.** The orchestrator (`meta-fix-bug.md`) writes the
+     `reported → triaged` and `triaged → in-progress` transitions on
+     return. Writing `bug.status` from this workflow is forbidden by
+     Iron Laws above and is rejected by the phase-ownership guard.
+   - **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.
+
+7. Emit Summary Sidecar:
+   - The JSON written in step 5 MUST have this shape (the `route` field
+     is required; allowed values: `"A"` or `"B"`):
+
+     ```json
+     {
+       "objective":   "Triage FORGE-BUG-NNN — reproduce, locate, decide route.",
+       "key_changes": ["<up to 12 bullets, 200 chars each — findings or actions>"],
+       "findings": [
+         "Root cause: <one line>",
+         "Reproduction: <one line>",
+         "Route decision: A | B",
+         "Rationale: <one line>"
+       ],
+       "verdict":     "n/a",
+       "written_at":  "<current ISO 8601 timestamp>",
+       "artifact_ref":"TRIAGE.md",
+       "route":       "A"
+     }
+     ```
+
+   - Call:
+     ```
+     forge_store({ command:"set-bug-summary", entity:"bug",
+                   id:"{bugId}", phase:"triage" })
+     // sidecar path auto-resolved from the bug record's `path` — never pass it
+     ```
+   - If the set-bug-summary call exits non-zero, fix the sidecar JSON
+     and retry (up to 3 attempts per the Store-Write Verification rule).
+     Do not proceed without a valid summary.
+
+> **Field-naming caution — runtime-tested.** The route field is named
+> `route`, never `path`. The bug schema's top-level `path` field is the
+> bug's **artifact directory** (e.g. `engineering/bugs/EMG-BUG-001-...`).
+> Conflating the two caused EMBERGLOW-BUG-001 (v0.44.0 first run) to land
+> its `TRIAGE.md` under `.forge/store/bugs/` instead of `engineering/bugs/`.
+> Triage MUST NOT touch `bug.path` — that field is set at bug creation
+> and never modified by triage.
+```
+
+## Path A / Path B Eligibility
+
+Path A is **eligible only when ALL** of the following hold. The triage
+summary `findings` array MUST enumerate each criterion explicitly with a
+pass/fail mark, so reviewers can audit the decision:
+
+- `bug.severity ∈ {minor}`
+- Fix is contained in a single file
+- Estimated diff ≤ ~20 lines (judgement call; one screen)
+- No schema, API, migration, security, or build-system change
+- A regression test is obvious from the reproduction script (single short
+  test case, no new fixtures, no test-harness change)
+
+If any criterion fails, the triage subagent MUST select Path B.
+
+**Path B is the default.** Any uncertainty resolves to Path B. It runs the
+same plan/review/implement/review/approve/commit shape as
+`meta-orchestrate.md`. Picking Path A under uncertainty is the documented
+failure mode (over-eager short-circuit).
+
+## Triage Artifact Contents (TRIAGE.md)
+
+The narrative artifact MUST contain:
+
+1. **Reported symptom** — one paragraph summarising the bug report.
+2. **Reproduction** — exact steps, commands, or test case that triggers
+   the symptom; copy of the failing output.
+3. **Root cause** — one or two paragraphs naming the defective code path,
+   schema, or workflow. Cite file paths and line numbers.
+4. **Path A / Path B enumeration** — for each criterion above, mark
+   pass/fail with one-line evidence.
+5. **Route decision and rationale** — the chosen route and the
+   single-sentence justification.
+6. **Collateral findings** — any related shapes, call sites, or
+   workflows that share the defective pattern (filed as follow-ups in
+   the commit phase, not fixed here).
+
+<!-- See _fragments/generation-instructions.md for Generation Instructions template -->
+## Friction Emit
+
+Emit `type:friction` `{workflow:triage, persona:bug-fixer, issue}` per
+`_fragments/friction-emit.md`.

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

@@ -110,10 +110,9 @@ deps:
        "artifact_ref":"VALIDATION_REPORT.md"
      }
      ```
-   - Call:
+   - Call (the sidecar path is auto-resolved from the task record's `path` — never pass it):
      ```
-     node "$FORGE_ROOT/tools/store-cli.cjs" set-summary {task_id} validation \
-       engineering/sprints/{sprint}/{task}/VALIDATION-SUMMARY.json
+     node "$FORGE_ROOT/tools/store-cli.cjs" set-summary {task_id} validation
      ```
    - If set-summary exits non-zero, fix the sidecar JSON and retry. Do not proceed without a valid summary.
 ```

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

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

package/dist/forge-payload/.schemas/_defs/locator.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "forge/_defs/locator.schema.json",
+  "title": "ArtifactLocator",
+  "description": "Backend-agnostic artifact locator (ADR doc/decisions/artifact-resolution-abstraction.md, issue #111 Phase 3). Single-sourced under _defs/ and $ref'd from task/bug/sprint schemas. `record.path` remains the required back-compat alias during migration; `locator` is the forward-looking form so a non-fs backend (s3/cms/db) is a drop-in. `ref` is an opaque, backend-specific reference (a URI is a fine encoding): fs → 'engineering/sprints/<dir>/<task>/', s3 → 's3://bucket/key', cms → 'cms://collection/<id>', db → 'blob:<uuid>'.",
+  "type": "object",
+  "required": ["backend", "ref"],
+  "properties": {
+    "backend": { "type": "string", "description": "Storage backend identifier — e.g. fs, s3, gcs, azure, cms, db." },
+    "ref":     { "type": "string", "description": "Opaque backend-specific reference (URI-encodable)." }
+  },
+  "additionalProperties": false
+}

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

@@ -11,6 +11,7 @@
     "severity":            { "type": "string", "enum": ["critical", "major", "minor"] },
     "status":              { "type": "string", "enum": ["reported", "triaged", "in-progress", "fixed"] },
     "path":                { "type": "string" },
+    "locator":             { "$ref": "_defs/locator.schema.json" },
     "rootCauseCategory": {
       "type": "string",
       "enum": ["validation", "auth", "business-rule", "data-integrity", "race-condition", "integration", "configuration", "regression"]

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

@@ -1,6 +1,6 @@
 {
-  "version": "1.0.2",
-  "generated": "2026-05-27",
+  "version": "1.0.10",
+  "generated": "2026-05-31",
   "note": "Authoritative enum catalog. Source: build-enum-catalog.cjs. Regenerate via node forge/tools/build-manifest.cjs.",
   "enums": {
     "task.status": [