@entelligentsia/forgecli 0.11.3 → 0.19.0

package/dist/extensions/forgecli/forge-artifact-tool.js

@@ -0,0 +1,185 @@
+// forge-artifact-tool.ts — typed artifact read/write/list tool for subagent sessions.
+//
+// Resolves phase artifact paths from (entityType, entityId, artifactName) tuples.
+// Validates JSON summary artifacts on write. Eliminates path derivation as a
+// failure mode for low-tier models.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Type } from "typebox";
+// ── Artifact catalog ────────────────────────────────────────────────────────
+const ARTIFACT_CATALOG = {
+    "plan": { filename: "PLAN.md", type: "md" },
+    "plan-review": { filename: "PLAN_REVIEW.md", type: "md" },
+    "progress": { filename: "PROGRESS.md", type: "md" },
+    "code-review": { filename: "CODE_REVIEW.md", type: "md" },
+    "validation-report": { filename: "VALIDATION_REPORT.md", type: "md" },
+    "architect-approval": { filename: "ARCHITECT_APPROVAL.md", type: "md" },
+    "triage": { filename: "TRIAGE.md", type: "md" },
+    "bug-report": { filename: "BUG_REPORT.md", type: "md" },
+    "index": { filename: "INDEX.md", type: "md" },
+    "cost-report": { filename: "COST_REPORT.md", type: "md" },
+    "timesheet": { filename: "TIMESHEET.md", type: "md" },
+    "plan-summary": { filename: "PLAN-SUMMARY.json", type: "json" },
+    "review-plan-summary": { filename: "REVIEW-PLAN-SUMMARY.json", type: "json" },
+    "implementation-summary": { filename: "IMPLEMENTATION-SUMMARY.json", type: "json" },
+    "review-code-summary": { filename: "REVIEW-CODE-SUMMARY.json", type: "json" },
+    "review-impl-summary": { filename: "REVIEW-IMPL-SUMMARY.json", type: "json" },
+    "validation-summary": { filename: "VALIDATION-SUMMARY.json", type: "json" },
+    "approve-summary": { filename: "APPROVE-SUMMARY.json", type: "json" },
+    "commit-summary": { filename: "COMMIT-SUMMARY.json", type: "json" },
+    "triage-summary": { filename: "TRIAGE-SUMMARY.json", type: "json" },
+    "writeback-summary": { filename: "WRITEBACK-SUMMARY.json", type: "json" },
+    "collation-summary": { filename: "COLLATION-SUMMARY.json", type: "json" },
+};
+const ARTIFACT_NAMES = Object.keys(ARTIFACT_CATALOG).sort();
+// ── Summary JSON validation ─────────────────────────────────────────────────
+const SUMMARY_REQUIRED = ["objective", "key_changes", "verdict", "written_at"];
+function validateSummaryJson(content) {
+    let obj;
+    try {
+        obj = JSON.parse(content);
+    }
+    catch (e) {
+        return `Invalid JSON: ${e.message}`;
+    }
+    const missing = SUMMARY_REQUIRED.filter((f) => !(f in obj));
+    if (missing.length > 0)
+        return `Missing required fields: ${missing.join(", ")}`;
+    if (typeof obj.objective !== "string")
+        return `"objective" must be a string`;
+    if (!Array.isArray(obj.key_changes))
+        return `"key_changes" must be an array`;
+    if (typeof obj.verdict !== "string")
+        return `"verdict" must be a string`;
+    if (typeof obj.written_at !== "string")
+        return `"written_at" must be a string`;
+    return null;
+}
+// ── Entity path resolution ──────────────────────────────────────────────────
+function resolveEntityDir(entity, entityId, engineeringPath) {
+    switch (entity) {
+        case "task": {
+            const match = entityId.match(/^(.+-S\d+)-T\d+$/);
+            if (!match)
+                return null;
+            return path.join(engineeringPath, "sprints", match[1], entityId);
+        }
+        case "bug":
+            return path.join(engineeringPath, "bugs", entityId);
+        case "sprint":
+            return path.join(engineeringPath, "sprints", entityId);
+        default:
+            return null;
+    }
+}
+// ── Tool builder ────────────────────────────────────────────────────────────
+export function buildForgeArtifact(projectRoot, engineeringPath) {
+    const artifactNameList = ARTIFACT_NAMES.join(", ");
+    return {
+        name: "forge_artifact",
+        label: "Forge Artifact",
+        description: "Read, write, or list phase artifacts (PLAN.md, PROGRESS.md, *-SUMMARY.json, etc.) " +
+            "for a task, bug, or sprint. Resolves paths automatically from entity ID — never " +
+            "construct artifact paths manually.\n\n" +
+            `Known artifacts: ${artifactNameList}.\n\n` +
+            "JSON summary artifacts are validated on write (objective, key_changes, verdict, written_at required). " +
+            "Use 'list' to see which artifacts already exist for an entity.",
+        promptSnippet: "Use forge_artifact to read/write phase outputs (PLAN.md, PROGRESS.md, *-SUMMARY.json). " +
+            "Never construct artifact paths manually — the tool resolves them from entity IDs.",
+        parameters: Type.Object({
+            command: Type.Union([Type.Literal("read"), Type.Literal("write"), Type.Literal("list")], { description: "read: fetch content. write: create/overwrite with validation. list: show existing artifacts." }),
+            entity: Type.Union([Type.Literal("task"), Type.Literal("bug"), Type.Literal("sprint")], { description: "Entity type." }),
+            entityId: Type.String({
+                description: "Entity ID (e.g. HELLO-S99-T02, HELLO-B01-shout-flag, HELLO-S99).",
+            }),
+            artifact: Type.Optional(Type.String({
+                description: `Artifact name (required for read/write). One of: ${artifactNameList}.`,
+            })),
+            content: Type.Optional(Type.String({
+                description: "Content to write (required for write command).",
+            })),
+        }),
+        async execute(_toolCallId, _params) {
+            const params = _params;
+            const entityDir = resolveEntityDir(params.entity, params.entityId, engineeringPath);
+            if (!entityDir) {
+                return errResult(`Cannot resolve ${params.entity} directory for "${params.entityId}". ` +
+                    `Expected ID pattern: task=PREFIX-SNN-TNN, bug=PREFIX-BNN-slug, sprint=PREFIX-SNN.`);
+            }
+            const absDir = path.resolve(projectRoot, entityDir);
+            if (params.command === "list") {
+                if (!fs.existsSync(absDir)) {
+                    return okResult(`No artifacts found — directory does not exist: ${entityDir}/`);
+                }
+                const files = fs.readdirSync(absDir).filter((f) => f.endsWith(".md") || f.endsWith(".json"));
+                const known = [];
+                const other = [];
+                for (const f of files) {
+                    const catalogEntry = Object.entries(ARTIFACT_CATALOG).find(([, v]) => v.filename === f);
+                    if (catalogEntry) {
+                        known.push(`  ${catalogEntry[0]} → ${f}`);
+                    }
+                    else {
+                        other.push(`  (unlisted) ${f}`);
+                    }
+                }
+                const lines = [`Artifacts in ${entityDir}/:`];
+                if (known.length > 0)
+                    lines.push(...known);
+                if (other.length > 0)
+                    lines.push(...other);
+                if (known.length === 0 && other.length === 0)
+                    lines.push("  (empty)");
+                return okResult(lines.join("\n"));
+            }
+            if (!params.artifact) {
+                return errResult(`"artifact" is required for ${params.command}. Known: ${artifactNameList}`);
+            }
+            const catalogEntry = ARTIFACT_CATALOG[params.artifact];
+            if (!catalogEntry) {
+                const suggestions = ARTIFACT_NAMES.filter((n) => n.includes(params.artifact.toLowerCase()));
+                return errResult(`Unknown artifact "${params.artifact}". Known: ${artifactNameList}.` +
+                    (suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : ""));
+            }
+            const filePath = path.join(absDir, catalogEntry.filename);
+            if (params.command === "read") {
+                if (!fs.existsSync(filePath)) {
+                    return errResult(`Artifact not found: ${path.join(entityDir, catalogEntry.filename)}`);
+                }
+                const content = fs.readFileSync(filePath, "utf8");
+                return okResult(content);
+            }
+            if (params.command === "write") {
+                if (!params.content) {
+                    return errResult(`"content" is required for write.`);
+                }
+                if (catalogEntry.type === "json") {
+                    const validationError = validateSummaryJson(params.content);
+                    if (validationError) {
+                        return errResult(`Summary validation failed for ${catalogEntry.filename}: ${validationError}. ` +
+                            `Required fields: ${SUMMARY_REQUIRED.join(", ")}.`);
+                    }
+                }
+                fs.mkdirSync(absDir, { recursive: true });
+                fs.writeFileSync(filePath, params.content, "utf8");
+                return okResult(`Wrote ${Buffer.byteLength(params.content, "utf8")} bytes to ${path.join(entityDir, catalogEntry.filename)}`);
+            }
+            return errResult(`Unknown command: ${params.command}`);
+        },
+    };
+}
+// ── Result helpers (same pattern as forge-tools.ts) ─────────────────────────
+function okResult(text) {
+    return {
+        content: [{ type: "text", text: text || "OK" }],
+        details: {},
+    };
+}
+function errResult(text) {
+    return {
+        content: [{ type: "text", text }],
+        details: {},
+        isError: true,
+    };
+}
+//# sourceMappingURL=forge-artifact-tool.js.map

package/dist/extensions/forgecli/forge-artifact-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-artifact-tool.js","sourceRoot":"","sources":["../../../src/extensions/forgecli/forge-artifact-tool.ts"],"names":[],"mappings":"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"}

package/dist/extensions/forgecli/forge-cli-schema.json

@@ -22,6 +22,25 @@
     },
     "properties": {
         "persona-models": { "$ref": "#/definitions/personaModelsMap" },
+        "forgeCli": {
+            "type": "object",
+            "description": "Feature flags and rollout gates for forge-cli runtime behaviour.",
+            "additionalProperties": false,
+            "properties": {
+                "skillCuration": {
+                    "type": "object",
+                    "description": "FORGE-S24 SKILL-CURATION pipeline (T08 retriever, T09 usage tracker, T10 curator subagent, T11 friction emitter). Default OFF — gated rollout per FORGE-S24-T12.",
+                    "additionalProperties": false,
+                    "properties": {
+                        "enabled": {
+                            "type": "boolean",
+                            "default": false,
+                            "description": "When false (default), every SKILL-CURATION module no-ops at entry and emits zero events / writes zero queue files. Promote to true on a per-project basis once the signal quality is observed in real-world runs."
+                        }
+                    }
+                }
+            }
+        },
         "pipelines": {
             "type": "object",
             "description": "Per-pipeline overrides. Pipeline names match the Forge plugin's pipeline catalogue.",

package/dist/extensions/forgecli/forge-init/phase-descriptors.d.ts

@@ -0,0 +1,72 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+export interface VerifyResult {
+    ok: boolean;
+    missing: string[];
+    reason?: string;
+}
+/** Context passed to the `postVerify` hook. */
+export interface PostVerifyContext {
+    cwd: string;
+    bundleRoot: string;
+    toolsRoot: string;
+    projectName: string;
+    configCache: Record<string, unknown>;
+    ctx: ExtensionCommandContext;
+    sendToAgent: (text: string) => void;
+    isNonInteractive: () => boolean;
+}
+/**
+ * Descriptor for a single init phase.
+ *
+ * LLM phases (1, 2): `buildPrompt` returns a string; `runLlmPhase` dispatches via
+ * `sendToAgent` + `waitForIdle` then verifies.
+ *
+ * Deterministic phases (3): `buildPrompt` returns `null`; `runDeterministic` runs
+ * tool calls directly without LLM dispatch.
+ */
+export interface LlmPhaseDescriptor {
+    phaseNum: 1 | 2 | 3;
+    label: string;
+    bannerName: string;
+    bannerKey: string;
+    /**
+     * Build the prompt to send to the agent. Return `null` for deterministic phases
+     * that run tool calls directly (Phase 3).
+     */
+    buildPrompt: (bundleRoot: string, cwd: string, projectName: string, configCache: Record<string, unknown>) => string | null;
+    /** Direct tool execution for deterministic phases (called when buildPrompt returns null). */
+    runDeterministic?: (cwd: string, bundleRoot: string, toolsRoot: string, configCache: Record<string, unknown>, ctx: ExtensionCommandContext) => Promise<void>;
+    /** Optional notification emitted before LLM dispatch (e.g. Phase 1 parallel-scan notice). */
+    preDispatchNotify?: string;
+    verify: (cwd: string, configCache: Record<string, unknown>) => VerifyResult;
+    buildRetrySteer: (result: VerifyResult, bundleRoot: string, cwd: string) => string | null;
+    nonInteractiveAbortMsg: (result: VerifyResult) => string;
+    interactiveAbortPrompt: (result: VerifyResult) => {
+        title: string;
+        body: string;
+    };
+    abortNotify: string;
+    partialContinueNotify: string;
+    completeNotify: string;
+    /** When true, a failed verify aborts immediately with no retry or user confirm. Default: false. */
+    hardFailOnVerifyError?: boolean;
+    /**
+     * Optional async hook invoked after the failure-handling decision completes (both on
+     * success and on partial-continue). NOT called when the phase returns "abort".
+     */
+    postVerify?: (ctx: PostVerifyContext) => Promise<void> | void;
+}
+/**
+ * Run a single init phase using its descriptor.
+ *
+ * Returns `"ok"` when the phase completes successfully (verify passed, or the
+ * user chose to continue with partial results).
+ *
+ * Returns `"abort"` when the phase should halt the entire init (verify failed
+ * in hard-fail mode, verify failed twice in non-interactive mode, or the user
+ * declined to continue).
+ */
+export declare function runLlmPhase(desc: LlmPhaseDescriptor, ctx: ExtensionCommandContext, cwd: string, bundleRoot: string, toolsRoot: string, projectName: string, configCache: Record<string, unknown>, sendToAgent: (text: string) => void, waitForIdle: () => Promise<void>, isNonInteractive: () => boolean): Promise<"ok" | "abort">;
+export declare const PHASE_1: LlmPhaseDescriptor;
+export declare const PHASE_2: LlmPhaseDescriptor;
+export declare const PHASE_3: LlmPhaseDescriptor;

package/dist/extensions/forgecli/forge-init/phase-descriptors.js

@@ -0,0 +1,350 @@
+// forge-init/phase-descriptors.ts — LlmPhaseDescriptor interface + runLlmPhase() runner
+// + per-phase descriptor objects (FORGE-S25-T24, B-5)
+//
+// Centralises the repeated "banner → [LLM dispatch → waitForIdle →] verify → [retry →]
+// [user confirm →] writeInitProgress → completeNotify" skeleton that was duplicated
+// across the Phase 1, 2, and 3 blocks in forge-init.ts.
+//
+// Design rules:
+//   - If `buildPrompt` returns a non-null string, the runner performs LLM dispatch via
+//     `sendToAgent` + `waitForIdle`. Phase 1 and 2 use this path.
+//   - If `buildPrompt` returns null, the runner skips LLM dispatch and invokes
+//     `runDeterministic` instead (Phase 3 path — pure tool calls, no agent).
+//   - `postVerify` is an optional async hook invoked after the failure-handling decision
+//     completes (i.e. after verify succeeds OR after user chooses partial-continue).
+//     Used by Phase 1 for KB folder prompt + marketplace advisory, by Phase 2 for
+//     project-context.json write and calibration baseline.
+//   - `hardFailOnVerifyError` (default false): when true, a failed verify causes an
+//     immediate `"abort"` return with no retry and no user confirm. Phase 3 uses this.
+//   - `preDispatchNotify` (optional): fired before LLM dispatch — used by Phase 1 to
+//     emit the "Running 5 discovery scans in parallel..." info notice.
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { execFileAsync, runToolAdvisory } from "../lib/exec-helpers.js";
+import { writeInitProgress } from "../init-progress.js";
+import { buildProjectContext, computeCalibrationBaseline, validateProjectContext, writeProjectContext, } from "../init-context.js";
+import { verifyPhase1, verifyPhase2, verifyPhase3 } from "./verifiers.js";
+import { buildPhase1PromptText, buildPhase2PromptText } from "./prompts.js";
+// ── Generic runner ─────────────────────────────────────────────────────────
+/**
+ * Run a single init phase using its descriptor.
+ *
+ * Returns `"ok"` when the phase completes successfully (verify passed, or the
+ * user chose to continue with partial results).
+ *
+ * Returns `"abort"` when the phase should halt the entire init (verify failed
+ * in hard-fail mode, verify failed twice in non-interactive mode, or the user
+ * declined to continue).
+ */
+export async function runLlmPhase(desc, ctx, cwd, bundleRoot, toolsRoot, projectName, configCache, sendToAgent, waitForIdle, isNonInteractive) {
+    // 1. setStatus
+    ctx.ui.setStatus?.("forge:init", `Phase ${desc.label}`);
+    // 2. Banner
+    const bannersTool = path.join(toolsRoot, "banners.cjs");
+    if (fs.existsSync(bannersTool)) {
+        await execFileAsync("node", [bannersTool, "--phase", String(desc.phaseNum), "4", desc.bannerName, desc.bannerKey], { cwd, timeout: 5000 }).catch(() => {
+            /* non-fatal */
+        });
+    }
+    // 3. Optional pre-dispatch notification
+    if (desc.preDispatchNotify) {
+        ctx.ui.notify(desc.preDispatchNotify, "info");
+    }
+    // 4. LLM dispatch OR deterministic execution
+    const prompt = desc.buildPrompt(bundleRoot, cwd, projectName, configCache);
+    if (prompt !== null) {
+        // LLM path: send prompt + wait for agent
+        sendToAgent(prompt);
+        await waitForIdle();
+    }
+    else if (desc.runDeterministic) {
+        // Deterministic path: run tool calls directly
+        await desc.runDeterministic(cwd, bundleRoot, toolsRoot, configCache, ctx);
+    }
+    // 5. Verify
+    let result = desc.verify(cwd, configCache);
+    if (!result.ok && desc.hardFailOnVerifyError) {
+        // Hard-fail: no retry, no user confirm (Phase 3)
+        ctx.ui.notify(desc.nonInteractiveAbortMsg(result), "error");
+        return "abort";
+    }
+    // 6. Retry steer (LLM phases only)
+    if (!result.ok && prompt !== null) {
+        const retrySteer = desc.buildRetrySteer(result, bundleRoot, cwd);
+        if (retrySteer) {
+            ctx.ui.notify(`△ Phase ${desc.phaseNum} deliverable missing: ${result.missing.join(", ")} — retrying with corrective steer.`, "warning");
+            sendToAgent(retrySteer);
+            await waitForIdle();
+            result = desc.verify(cwd, configCache);
+        }
+    }
+    // 7. Handle persistent failure
+    if (!result.ok) {
+        if (isNonInteractive()) {
+            ctx.ui.notify(desc.nonInteractiveAbortMsg(result), "error");
+            return "abort";
+        }
+        const { title, body } = desc.interactiveAbortPrompt(result);
+        const proceed = await ctx.ui.confirm(title, body);
+        if (!proceed) {
+            ctx.ui.notify(desc.abortNotify, "error");
+            return "abort";
+        }
+        ctx.ui.notify(desc.partialContinueNotify, "warning");
+    }
+    // 8. Post-verify hook (called on success AND on partial-continue)
+    if (desc.postVerify) {
+        await desc.postVerify({ cwd, bundleRoot, toolsRoot, projectName, configCache, ctx, sendToAgent, isNonInteractive });
+    }
+    // 9. Write progress marker + completion notify
+    writeInitProgress(cwd, desc.phaseNum);
+    ctx.ui.notify(desc.completeNotify, "info");
+    return "ok";
+}
+// ── Phase descriptors ──────────────────────────────────────────────────────
+export const PHASE_1 = {
+    phaseNum: 1,
+    label: "1/4: Collect",
+    bannerName: "Collect",
+    bannerKey: "north",
+    preDispatchNotify: "Running 5 discovery scans in parallel...",
+    buildPrompt(bundleRoot, _cwd, projectName, _configCache) {
+        return buildPhase1PromptText(bundleRoot, projectName);
+    },
+    verify(cwd, _configCache) {
+        return verifyPhase1(cwd);
+    },
+    buildRetrySteer(result, _bundleRoot, _cwd) {
+        return (`Phase 1 verification failed. .forge/config.json is missing the following required fields: ${result.missing.join(", ")}.\n\n` +
+            `Write a complete .forge/config.json now using the \`write\` tool. Do NOT call subagents — analyze the project codebase yourself if needed. ` +
+            `Use the schema from the original Phase 1 prompt: version, project.{name,prefix}, stack, commands, and paths.{engineering,store,workflows,commands,templates} are all required.`);
+    },
+    nonInteractiveAbortMsg(result) {
+        return `× Phase 1 failed: ${result.missing.join(", ")}. Aborting init in non-interactive mode.`;
+    },
+    interactiveAbortPrompt(result) {
+        return {
+            title: "Phase 1 failed twice — continue with partial init?",
+            body: `.forge/config.json is still missing: ${result.missing.join(", ")}.\n\n` +
+                `Yes = continue (you'll need to /forge:regenerate later).\n` +
+                `No  = abort. Inspect the file manually and re-run /forge:init.`,
+        };
+    },
+    abortNotify: "× /forge:init aborted at Phase 1 verify.",
+    partialContinueNotify: "△ Continuing with partial Phase 1 — downstream phases may fail.",
+    completeNotify: "〇 Phase 1 complete.",
+    async postVerify({ cwd, toolsRoot, configCache, ctx, isNonInteractive }) {
+        // KB folder prompt (spec §7, F2) — G3: skipped in non-interactive mode (default: "engineering")
+        // Phrasing chosen so the default-Yes affirmative ("use engineering/") is the
+        // safe path. Pi's ctx.ui.confirm has no defaultValue option, so the question
+        // has to align with the highlighted default — earlier "does this conflict?"
+        // phrasing made the unsafe answer the default.
+        if (!isNonInteractive()) {
+            const kbDescription = `Forge will create a folder for architecture docs, sprints, bugs, and features.\n\n` +
+                `Use "engineering" as the folder name?  (Pick No only if your project already has an "engineering/" folder you don't want Forge to touch.)`;
+            const useDefault = await ctx.ui.confirm("Engineering folder name?", kbDescription);
+            if (!useDefault) {
+                const customName = await ctx.ui.input("Engineering folder name? Enter preferred folder name", "e.g. ai-docs, .forge-kb, docs/ai");
+                if (customName && customName.trim()) {
+                    const manageConfigToolEarly = path.join(toolsRoot, "manage-config.cjs");
+                    if (fs.existsSync(manageConfigToolEarly)) {
+                        await runToolAdvisory(manageConfigToolEarly, ["set", "paths.engineering", customName.trim()], cwd, ctx, "manage-config paths.engineering");
+                    }
+                }
+            }
+        }
+        // Marketplace skills advisory (sub-decision #1)
+        ctx.ui.notify("〇 Marketplace skills auto-recommendation is Claude-Code-only. " +
+            "Pi users install extensions manually. Writing installedSkills: []", "info");
+        // Write installedSkills: []
+        const manageConfigTool = path.join(toolsRoot, "manage-config.cjs");
+        if (fs.existsSync(manageConfigTool)) {
+            await runToolAdvisory(manageConfigTool, ["set", "installedSkills", "[]"], cwd, ctx, "manage-config installedSkills");
+            // Write mode = "full"
+            await runToolAdvisory(manageConfigTool, ["set", "mode", "full"], cwd, ctx, "manage-config mode");
+        }
+        void configCache; // used by descriptor runner; accessed here only to satisfy type
+    },
+};
+export const PHASE_2 = {
+    phaseNum: 2,
+    label: "2/4: Discover",
+    bannerName: "Discover",
+    bannerKey: "oracle",
+    buildPrompt(bundleRoot, cwd, projectName, configCache) {
+        let kbPath = "engineering";
+        const cachePaths = configCache.paths;
+        if (cachePaths && typeof cachePaths.engineering === "string" && cachePaths.engineering) {
+            kbPath = cachePaths.engineering;
+        }
+        // Scaffold dirs before dispatching to ensure they exist
+        const dirs = [
+            path.join(cwd, kbPath),
+            path.join(cwd, kbPath, "architecture"),
+            path.join(cwd, kbPath, "business-domain"),
+            path.join(cwd, kbPath, "sprints"),
+            path.join(cwd, ".forge", "store"),
+            path.join(cwd, ".forge", "cache"),
+        ];
+        for (const dir of dirs) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                const keepPath = path.join(dir, ".gitkeep");
+                if (!fs.existsSync(keepPath)) {
+                    fs.writeFileSync(keepPath, "", "utf8");
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        return buildPhase2PromptText(bundleRoot, kbPath, projectName);
+    },
+    verify(cwd, configCache) {
+        let kbPath = "engineering";
+        const cachePaths = configCache.paths;
+        if (cachePaths && typeof cachePaths.engineering === "string" && cachePaths.engineering) {
+            kbPath = cachePaths.engineering;
+        }
+        return verifyPhase2(cwd, kbPath);
+    },
+    buildRetrySteer(result, bundleRoot, _cwd) {
+        return (`Phase 2 verification failed. The following architecture docs are missing:\n${result.missing.map((m) => `  - ${m}`).join("\n")}\n\n` +
+            `Write the missing files now using the \`write\` tool. Do NOT call subagents — analyze the project codebase yourself. ` +
+            `Use the rulebook at ${path.join(bundleRoot, ".init", "generation", "generate-kb-doc.md")} for the per-doc shape and confidence-header format.`);
+    },
+    nonInteractiveAbortMsg(result) {
+        return `× Phase 2 failed: ${result.missing.length} doc(s) still missing. Aborting init in non-interactive mode.`;
+    },
+    interactiveAbortPrompt(result) {
+        return {
+            title: "Phase 2 failed twice — continue with partial init?",
+            body: `Missing docs:\n${result.missing.map((m) => `  - ${m}`).join("\n")}\n\n` +
+                `Yes = continue (you'll need to fill these manually).\n` +
+                `No  = abort. Inspect the project and re-run /forge:init.`,
+        };
+    },
+    abortNotify: "× /forge:init aborted at Phase 2 verify.",
+    partialContinueNotify: "△ Continuing with partial Phase 2.",
+    completeNotify: "〇 Phase 2 complete.",
+    async postVerify({ cwd, bundleRoot, toolsRoot, projectName, configCache, ctx }) {
+        // Construct project-context.json — use configCache (written by Phase 1)
+        let kbPathResolved = "engineering";
+        let prefix = "";
+        {
+            const cacheProj = configCache.project;
+            if (cacheProj && typeof cacheProj.prefix === "string")
+                prefix = cacheProj.prefix;
+            const cachePaths2 = configCache.paths;
+            if (cachePaths2 && typeof cachePaths2.engineering === "string")
+                kbPathResolved = cachePaths2.engineering;
+        }
+        const projectCtx = buildProjectContext({
+            projectName: configCache.project?.name ?? projectName,
+            prefix,
+            kbPath: kbPathResolved,
+        }, configCache);
+        try {
+            validateProjectContext(projectCtx);
+            writeProjectContext(cwd, projectCtx);
+            ctx.ui.notify("〇 project-context.json written.", "info");
+        }
+        catch (err) {
+            const e = err;
+            ctx.ui.notify(`△ project-context.json validation failed: ${e.message ?? "unknown"} — proceeding.`, "warning");
+        }
+        // Calibration baseline — read bundled version from plugin.json (same pattern as phase4-register.ts step 4-8)
+        let bundledPluginVersion = "";
+        try {
+            const pluginPath = path.join(bundleRoot, ".claude-plugin", "plugin.json");
+            const plugin = JSON.parse(fs.readFileSync(pluginPath, "utf8"));
+            bundledPluginVersion = plugin.version ?? "";
+        }
+        catch {
+            // non-fatal — version field stays ""
+        }
+        const baseline = computeCalibrationBaseline(cwd, kbPathResolved, bundledPluginVersion);
+        const manageConfigTool = path.join(toolsRoot, "manage-config.cjs");
+        if (fs.existsSync(manageConfigTool)) {
+            await runToolAdvisory(manageConfigTool, ["set", "calibrationBaseline", JSON.stringify(baseline)], cwd, ctx, "manage-config calibrationBaseline");
+        }
+    },
+};
+export const PHASE_3 = {
+    phaseNum: 3,
+    label: "3/4: Materialize",
+    bannerName: "Materialize",
+    bannerKey: "supervisor",
+    // Phase 3 is deterministic — no LLM dispatch.
+    buildPrompt(_bundleRoot, _cwd, _projectName, _configCache) {
+        return null;
+    },
+    async runDeterministic(cwd, bundleRoot, toolsRoot, _configCache, ctx) {
+        const buildInitContextTool = path.join(toolsRoot, "build-init-context.cjs");
+        const substituteTool = path.join(toolsRoot, "substitute-placeholders.cjs");
+        const buildOverlayTool = path.join(toolsRoot, "build-overlay.cjs");
+        const basePackDir = path.join(bundleRoot, ".base-pack");
+        // 3a: build-init-context.cjs first build
+        if (fs.existsSync(buildInitContextTool)) {
+            await runToolAdvisory(buildInitContextTool, [
+                "--config",
+                path.join(cwd, ".forge", "config.json"),
+                "--personas",
+                path.join(cwd, ".forge", "personas"),
+                "--templates",
+                path.join(cwd, ".forge", "templates"),
+                "--kb",
+                cwd,
+                "--out",
+                path.join(cwd, ".forge", "init-context.md"),
+                "--json-out",
+                path.join(cwd, ".forge", "init-context.json"),
+            ], cwd, ctx, "build-init-context", 30000);
+        }
+        // 3b: substitute-placeholders.cjs — base-pack materialisation
+        if (fs.existsSync(substituteTool) && fs.existsSync(basePackDir)) {
+            await runToolAdvisory(substituteTool, [
+                "--forge-root",
+                bundleRoot,
+                "--base-pack",
+                basePackDir,
+                "--config",
+                path.join(cwd, ".forge", "config.json"),
+                "--context",
+                path.join(cwd, ".forge", "init-context.json"),
+                "--out",
+                cwd,
+            ], cwd, ctx, "substitute-placeholders", 60000);
+        }
+        // 3c: build-overlay.cjs smoke test (exit 1 is advisory)
+        if (fs.existsSync(buildOverlayTool)) {
+            await runToolAdvisory(buildOverlayTool, ["--task", "INIT-SMOKE-TEST", "--format", "json"], cwd, ctx, "build-overlay smoke (advisory)", 15000);
+        }
+    },
+    verify(cwd, _configCache) {
+        return verifyPhase3(cwd);
+    },
+    buildRetrySteer(_result, _bundleRoot, _cwd) {
+        // Phase 3 hard-fails — retry steer is not used.
+        return null;
+    },
+    nonInteractiveAbortMsg(result) {
+        return (`× Phase 3 failed: ${result.missing.join(", ")}. ` +
+            `This usually means substitute-placeholders.cjs ran against an incomplete config. ` +
+            `Fix .forge/config.json and run /forge:regenerate, or restart /forge:init from scratch (delete .forge/init-progress.json).`);
+    },
+    interactiveAbortPrompt(result) {
+        return {
+            title: "Phase 3 failed — abort init?",
+            body: `Phase 3 materialization failed: ${result.missing.join(", ")}.\n\n` +
+                `This usually means substitute-placeholders.cjs ran against an incomplete config.\n` +
+                `Fix .forge/config.json and run /forge:regenerate.`,
+        };
+    },
+    abortNotify: "× /forge:init aborted at Phase 3 verify.",
+    partialContinueNotify: "△ Continuing with partial Phase 3.",
+    completeNotify: "〇 Phase 3 complete.",
+    // Phase 3 hard-fails on verify error — no retry, no user confirm.
+    hardFailOnVerifyError: true,
+};
+//# sourceMappingURL=phase-descriptors.js.map