@loucompanion/forge-bridge 0.1.3-dev.04a84914da09 → 0.1.3-dev.f66395c3ac21

package/dist/session/phase-completion.d.ts

@@ -4,11 +4,9 @@ export type DevelopCompletionPhase = "implementation" | "self_review" | "validat
 export type DebugCompletionPhase = "debug_repro" | "debug_root_cause" | "debug_fix" | "debug_regression";
 export type ArchitectCompletionPhase = "architect";
 export type DraftCompletionPhase = "draft";
-export type DecomposeCompletionPhase = "decompose";
-export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase | DecomposeCompletionPhase;
+export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase;
 export type QaCompletionGate = "qa_plan" | "qa_regression" | "qa_api" | "qa_manual_web" | "qa_bug_repro" | "qa_findings" | "qa_verdict";
 export type DraftCompletionGate = "draft_intent" | "draft_repo_context" | "draft_graph_context" | "draft_product_scope" | "draft_work_order_plan" | "draft_critic" | "draft_proposal";
-export type DecomposeCompletionGate = "decompose_subject_intake" | "decompose_context_review" | "decompose_breakdown_strategy" | "decompose_child_items" | "decompose_dependency_graph" | "decompose_critic" | "decompose_proposal";
 export interface CompletionToolRuntime {
     readonly serverName: string;
     readonly command: string;
@@ -35,7 +33,6 @@ export interface CompletionToolServerConfig {
     readonly debugCycle?: boolean;
     readonly architectCycle?: boolean;
     readonly draftCycle?: boolean;
-    readonly decomposeCycle?: boolean;
 }
 export interface CompletionToolCallResult {
     readonly content: readonly {
@@ -47,7 +44,6 @@ export interface CompletionToolCallResult {
             readonly phase: CompletionPhase;
             readonly qaGate?: QaCompletionGate;
             readonly draftGate?: DraftCompletionGate;
-            readonly decomposeGate?: DecomposeCompletionGate;
             readonly status: string;
             readonly allowed: boolean;
             readonly reason: string;
@@ -71,7 +67,6 @@ export interface CompletionArtifactReference {
 export declare const debugCompletionPhaseOrder: readonly DebugCompletionPhase[];
 export declare const qaCompletionGateOrder: readonly QaCompletionGate[];
 export declare const draftCompletionGateOrder: readonly DraftCompletionGate[];
-export declare const decomposeCompletionGateOrder: readonly DecomposeCompletionGate[];
 export declare function completionPhaseFromDispatch(dispatch: RunOnceDispatchPacket): CompletionPhase;
 export declare function normalizeCompletionPhase(value: string | null | undefined): CompletionPhase;
 export declare function usesDevelopCycleCompletion(dispatch: RunOnceDispatchPacket): boolean;
@@ -82,12 +77,10 @@ export declare function completionToolNamesForPhase(phase: CompletionPhase): rea
 export declare function completionToolNamesForQaGate(gate: QaCompletionGate): readonly string[];
 export declare function completionToolNamesForDebugGate(gate: DebugCompletionPhase): readonly string[];
 export declare function completionToolNamesForDraftGate(gate: DraftCompletionGate): readonly string[];
-export declare function completionToolNamesForDecomposeGate(gate: DecomposeCompletionGate): readonly string[];
 export declare function expectedCompletionToolName(phase: CompletionPhase): string;
 export declare function expectedQaCompletionToolName(gate: QaCompletionGate): string;
 export declare function expectedDebugCompletionToolName(gate: DebugCompletionPhase): string;
 export declare function expectedDraftCompletionToolName(gate: DraftCompletionGate): string;
-export declare function expectedDecomposeCompletionToolName(gate: DecomposeCompletionGate): string;
 export declare function artifactRootFor(worktreePath: string, workItemId: string): string;
 export declare function artifactRootForOwner(worktreePath: string, ownerType: string, ownerId: string): string;
 export declare function completionArtifactJsonPath(worktreePath: string, workItemId: string, phase: CompletionPhase, ownerType?: string | null, ownerId?: string | null): string;
@@ -100,7 +93,6 @@ export declare function completionPromptForPhase(phase: CompletionPhase): string
 export declare function completionPromptForDevelopCycle(phase: CompletionPhase): string;
 export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate): string;
 export declare function completionPromptForDraftCycle(currentGate?: DraftCompletionGate): string;
-export declare function completionPromptForDecomposeCycle(currentGate?: DecomposeCompletionGate): string;
 export declare function completionPromptForDebugCycle(currentGate?: DebugCompletionPhase): string;
 export declare function completionToolNamesForServer(config: CompletionToolServerConfig): readonly string[];
 export declare class CompletionToolServerSession {
@@ -108,18 +100,15 @@ export declare class CompletionToolServerSession {
     private currentPhase;
     private currentQaGate;
     private currentDraftGate;
-    private currentDecomposeGate;
     private completed;
     constructor(config: CompletionToolServerConfig);
     get instructions(): string;
     toolDefinitions(): readonly unknown[];
     callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult>;
-    private callDecomposeGateTool;
     private callDraftGateTool;
     private callDebugGateTool;
     private callQaGateTool;
     private advanceAfterPass;
-    private advanceAfterDecomposeGate;
     private advanceAfterDraftGate;
     private advanceAfterQaGate;
     private advanceAfterDebugGate;

package/dist/session/phase-completion.js

@@ -31,33 +31,6 @@ export const draftCompletionGateOrder = [
     "draft_critic",
     "draft_proposal"
 ];
-export const decomposeCompletionGateOrder = [
-    "decompose_subject_intake",
-    "decompose_context_review",
-    "decompose_breakdown_strategy",
-    "decompose_child_items",
-    "decompose_dependency_graph",
-    "decompose_critic",
-    "decompose_proposal"
-];
-const decomposeGateFileNames = {
-    decompose_subject_intake: "decompose.subject-intake.json",
-    decompose_context_review: "decompose.context-review.json",
-    decompose_breakdown_strategy: "decompose.breakdown-strategy.json",
-    decompose_child_items: "decompose.child-items.json",
-    decompose_dependency_graph: "decompose.dependency-graph.json",
-    decompose_critic: "decompose.critic.json",
-    decompose_proposal: "decompose.proposal.json"
-};
-const decomposeGateToolNames = {
-    decompose_subject_intake: "complete_decompose_subject_intake",
-    decompose_context_review: "complete_decompose_context_review",
-    decompose_breakdown_strategy: "complete_decompose_breakdown_strategy",
-    decompose_child_items: "complete_decompose_child_items",
-    decompose_dependency_graph: "complete_decompose_dependency_graph",
-    decompose_critic: "complete_decompose_critic",
-    decompose_proposal: "complete_decompose_proposal"
-};
 const draftGateFileNames = {
     draft_intent: "draft.intent.json",
     draft_repo_context: "draft.repo-context.json",
@@ -153,10 +126,6 @@ const phaseFiles = {
     draft: {
         jsonFileName: "draft.proposal.json",
         reportFileName: "draft.report.md"
-    },
-    decompose: {
-        jsonFileName: "decompose.proposal.json",
-        reportFileName: "decompose.report.md"
     }
 };
 export function completionPhaseFromDispatch(dispatch) {
@@ -183,9 +152,6 @@ export function normalizeCompletionPhase(value) {
     if (normalized === "draft" || normalized === "drafting" || normalized === "draft_work_order") {
         return "draft";
     }
-    if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
-        return "decompose";
-    }
     return "implementation";
 }
 export function usesDevelopCycleCompletion(dispatch) {
@@ -225,9 +191,6 @@ export function completionToolNamesForPhase(phase) {
     if (phase === "draft") {
         return completionToolNamesForDraftGate("draft_proposal");
     }
-    if (phase === "decompose") {
-        return completionToolNamesForDecomposeGate("decompose_proposal");
-    }
     if (isDebugCompletionPhase(phase)) {
         return completionToolNamesForDebugGate(phase);
     }
@@ -254,10 +217,6 @@ export function completionToolNamesForDraftGate(gate) {
     const base = draftGateToolNames[gate];
     return [`forge.${base}`, base];
 }
-export function completionToolNamesForDecomposeGate(gate) {
-    const base = decomposeGateToolNames[gate];
-    return [`forge.${base}`, base];
-}
 export function expectedCompletionToolName(phase) {
     return completionToolNamesForPhase(phase)[0];
 }
@@ -270,9 +229,6 @@ export function expectedDebugCompletionToolName(gate) {
 export function expectedDraftCompletionToolName(gate) {
     return completionToolNamesForDraftGate(gate)[0];
 }
-export function expectedDecomposeCompletionToolName(gate) {
-    return completionToolNamesForDecomposeGate(gate)[0];
-}
 export function artifactRootFor(worktreePath, workItemId) {
     return path.join(worktreePath, ".forge", "work-items", safePathSegment(workItemId, "work item id"), "artifacts");
 }
@@ -308,11 +264,7 @@ export async function prepareCompletionToolRuntime(options) {
         qaCycle: usesQaCycleCompletion(options.dispatch),
         debugCycle: usesDebugCycleCompletion(options.dispatch),
         architectCycle: usesArchitectCycleCompletion(options.dispatch),
-        draftCycle: (phase === "draft"
-            || options.dispatch.execution.lane.trim().toLowerCase() === "draft"
-            || options.dispatch.cycleRun.kind.trim().toLowerCase() === "draft")
-            && !isDecomposeDispatch(options.dispatch),
-        decomposeCycle: isDecomposeDispatch(options.dispatch)
+        draftCycle: options.dispatch.execution.lane.trim().toLowerCase() === "draft" || options.dispatch.cycleRun.kind.trim().toLowerCase() === "draft"
     });
     const runtime = {
         serverName: toolServerName,
@@ -357,9 +309,6 @@ export function buildCompletionToolServerArgs(config) {
     if (config.draftCycle) {
         args.push("--draft-cycle");
     }
-    if (config.decomposeCycle) {
-        args.push("--decompose-cycle");
-    }
     return args;
 }
 export function codexMcpConfigArgs(runtime) {
@@ -442,27 +391,11 @@ Complete the Draft cycle in order inside this same provider session:
 2. Follow the returned repo-context instruction, inspect selected project/repo assumptions, then call \`forge.complete_draft_repo_context(...)\`.
 3. Follow the returned graph-context instruction, account for DAG/dependency placement, then call \`forge.complete_draft_graph_context(...)\`.
 4. Follow the returned product-scope instruction, choose product scope for the selected project, then call \`forge.complete_draft_product_scope(...)\`.
-5. Follow the returned work-order-plan instruction, draft the requested final JSON shape and any candidate boundaries, then call \`forge.complete_draft_work_order_plan(...)\`.
+5. Follow the returned work-order-plan instruction, draft Work Order fields and candidate feature boundaries, then call \`forge.complete_draft_work_order_plan(...)\`.
 6. Follow the returned critic instruction, critique literalism, wrong-project scope, and decomposition quality, then call \`forge.complete_draft_critic(...)\`.
-7. Follow the returned proposal instruction, then call \`forge.complete_draft_proposal(...)\` with the final Draft JSON payload in \`draft_json\`.
+7. Follow the returned proposal instruction, then call \`forge.complete_draft_proposal(...)\` with the final Work Order JSON in \`draft_json\`.
 The final proposal tool writes \`draft.proposal.json\` under \`.forge/work-items/{workItemId}/artifacts/\`. Reporting Draft completion in prose is not enough.`;
 }
-export function completionPromptForDecomposeCycle(currentGate = "decompose_subject_intake") {
-    return `# Forge Decompose completion cycle
-You must complete the Decompose gates in order using the Forge MCP tools. Reporting progress in prose is not enough.
-
-Current gate: ${currentGate}
-
-Required order:
-1. Call \`forge.complete_decompose_subject_intake(...)\` after identifying the Work Order/Feature subject, scope, and non-goals.
-2. Follow the returned context-review instruction, inspect injected project/repo/dependency context, then call \`forge.complete_decompose_context_review(...)\`.
-3. Follow the returned breakdown-strategy instruction, choose safe Feature/Story boundaries, then call \`forge.complete_decompose_breakdown_strategy(...)\`.
-4. Follow the returned child-items instruction, draft candidate child items, then call \`forge.complete_decompose_child_items(...)\`.
-5. Follow the returned dependency-graph instruction, validate keys/dependencies/order, then call \`forge.complete_decompose_dependency_graph(...)\`.
-6. Follow the returned critic instruction, critique scope, DAG safety, manual reconciliation risk, and missing acceptance detail, then call \`forge.complete_decompose_critic(...)\`.
-7. Follow the returned proposal instruction, then call \`forge.complete_decompose_proposal(...)\` with final JSON in \`proposal_json\`.
-The final proposal tool writes \`decompose.proposal.json\` under \`.forge/work-items/{workItemId}/artifacts/\`. The proposal_json object must contain summary, optional blockedReason, and candidates.`;
-}
 export function completionPromptForDebugCycle(currentGate = "debug_repro") {
     return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write Debug artifacts by hand. The tool server enforces Debug gate order and starts this run at \`${currentGate}\`.
@@ -475,43 +408,38 @@ Each tool writes a canonical Debug artifact under \`.forge/work-items/{workItemI
 Use a non-pass status with explicit blockers when the current Debug gate cannot pass. Reporting Debug completion in prose is not enough; the relevant MCP completion tool is the transition request.`;
 }
 export function completionToolNamesForServer(config) {
-    return config.decomposeCycle
-        ? decomposeCompletionGateOrder.flatMap((gate) => completionToolNamesForDecomposeGate(gate))
-        : config.draftCycle
-            ? draftCompletionGateOrder.flatMap((gate) => completionToolNamesForDraftGate(gate))
-            : config.debugCycle
-                ? debugCompletionPhaseOrder.flatMap((gate) => completionToolNamesForDebugGate(gate))
-                : config.qaCycle
-                    ? qaCompletionGateOrder.flatMap((gate) => completionToolNamesForQaGate(gate))
-                    : config.developCycle
-                        ? completionPhaseOrder.flatMap((phase) => completionToolNamesForPhase(phase))
-                        : config.architectCycle
-                            ? completionToolNamesForPhase("architect")
-                            : completionToolNamesForPhase(config.phase);
+    return config.draftCycle
+        ? draftCompletionGateOrder.flatMap((gate) => completionToolNamesForDraftGate(gate))
+        : config.debugCycle
+            ? debugCompletionPhaseOrder.flatMap((gate) => completionToolNamesForDebugGate(gate))
+            : config.qaCycle
+                ? qaCompletionGateOrder.flatMap((gate) => completionToolNamesForQaGate(gate))
+                : config.developCycle
+                    ? completionPhaseOrder.flatMap((phase) => completionToolNamesForPhase(phase))
+                    : config.architectCycle
+                        ? completionToolNamesForPhase("architect")
+                        : completionToolNamesForPhase(config.phase);
 }
 export class CompletionToolServerSession {
     config;
     currentPhase;
     currentQaGate = "qa_plan";
     currentDraftGate = "draft_intent";
-    currentDecomposeGate = "decompose_subject_intake";
     completed = false;
     constructor(config) {
         this.config = config;
         this.currentPhase = config.phase;
     }
     get instructions() {
-        return this.config.decomposeCycle
-            ? completionPromptForDecomposeCycle(this.currentDecomposeGate)
-            : this.config.draftCycle
-                ? completionPromptForDraftCycle(this.currentDraftGate)
-                : this.config.debugCycle
-                    ? completionPromptForDebugCycle(asDebugCompletionPhase(this.currentPhase))
-                    : this.config.qaCycle
-                        ? completionPromptForQaCycle(this.currentQaGate)
-                        : this.config.developCycle
-                            ? completionPromptForDevelopCycle(this.currentPhase)
-                            : completionPromptForPhase(this.currentPhase);
+        return this.config.draftCycle
+            ? completionPromptForDraftCycle(this.currentDraftGate)
+            : this.config.debugCycle
+                ? completionPromptForDebugCycle(asDebugCompletionPhase(this.currentPhase))
+                : this.config.qaCycle
+                    ? completionPromptForQaCycle(this.currentQaGate)
+                    : this.config.developCycle
+                        ? completionPromptForDevelopCycle(this.currentPhase)
+                        : completionPromptForPhase(this.currentPhase);
     }
     toolDefinitions() {
         return completionToolNamesForServer(this.config).map((name) => toolDefinition(name, phaseFromToolName(name), qaGateFromToolName(name)));
@@ -521,9 +449,6 @@ export class CompletionToolServerSession {
         if (this.completed) {
             throw new Error("Forge completion cycle is already complete; no more completion calls are accepted.");
         }
-        if (this.config.decomposeCycle) {
-            return await this.callDecomposeGateTool(toolName, requestedPhase, input);
-        }
         if (this.config.draftCycle) {
             return await this.callDraftGateTool(toolName, requestedPhase, input);
         }
@@ -567,38 +492,6 @@ export class CompletionToolServerSession {
             }
         };
     }
-    async callDecomposeGateTool(toolName, requestedPhase, input) {
-        const requestedGate = decomposeGateFromToolName(toolName);
-        if (requestedPhase !== "decompose" || !requestedGate) {
-            throw new Error(`Tool ${toolName} is not available in Decompose-cycle mode. Current Forge Decompose gate is ${this.currentDecomposeGate}.`);
-        }
-        if (requestedGate !== this.currentDecomposeGate) {
-            throw new Error(`Tool ${toolName} is out of order. Current Forge Decompose gate is ${this.currentDecomposeGate}.`);
-        }
-        const completedGate = this.currentDecomposeGate;
-        const reference = await writeDecomposeGateCompletionArtifact(this.config, completedGate, toolName, input);
-        const status = reference.status.trim().toLowerCase();
-        const pass = status === "pass";
-        const nextGate = pass ? this.advanceAfterDecomposeGate(completedGate) : completedGate;
-        const nextPhase = pass
-            ? (nextGate ? "decompose" : "sign_off_ready")
-            : "decompose";
-        const nextInstruction = completionToolNextInstructionForDecomposeGate(completedGate, status, nextGate);
-        const reason = pass
-            ? nextGate
-                ? `${completedGate} artifact accepted; continue to ${nextGate}.`
-                : `Decompose proposal artifact accepted with status ${status}.`
-            : `${completedGate} artifact recorded with status ${status}; rework is required before continuing.`;
-        return {
-            content: [{ type: "text", text: `Forge recorded ${completedGate} artifact ${path.relative(reference.repoPath, reference.path)} (${reference.status}, ${reference.contentHash}). ${nextInstruction}` }],
-            structuredContent: {
-                ...reference,
-                gate: { phase: "decompose", decomposeGate: completedGate, status, allowed: pass, reason },
-                nextPhase,
-                nextInstruction
-            }
-        };
-    }
     async callDraftGateTool(toolName, requestedPhase, input) {
         const requestedGate = draftGateFromToolName(toolName);
         if (requestedPhase !== "draft" || !requestedGate) {
@@ -719,16 +612,6 @@ export class CompletionToolServerSession {
         this.completed = true;
         return "dev_test_ready";
     }
-    advanceAfterDecomposeGate(gate) {
-        const index = decomposeCompletionGateOrder.indexOf(gate);
-        const next = index >= 0 ? decomposeCompletionGateOrder[index + 1] ?? null : null;
-        if (next) {
-            this.currentDecomposeGate = next;
-            return next;
-        }
-        this.completed = true;
-        return null;
-    }
     advanceAfterDraftGate(gate) {
         const index = draftCompletionGateOrder.indexOf(gate);
         const next = index >= 0 ? draftCompletionGateOrder[index + 1] ?? null : null;
@@ -760,46 +643,16 @@ export class CompletionToolServerSession {
         return null;
     }
 }
-async function writeDecomposeGateCompletionArtifact(config, gate, toolName, input) {
-    const payload = asRecord(input, "Decompose completion payload");
-    const status = normalizeDraftStatus(optionalString(payload, "status") ?? "pass");
-    if (gate === "decompose_proposal") {
-        const proposalJson = asRecord(payload["proposal_json"] ?? payload["decomposition_json"], "proposal_json");
-        if (!Array.isArray(proposalJson["candidates"])) {
-            throw new Error("proposal_json.candidates: expected array");
-        }
-    }
-    const redactedPayload = redactSecrets({ ...payload, status, phase: "decompose", gate, tool_name: toolName }, config.redactionSecrets ?? []);
-    const root = artifactRootFor(config.worktreePath, config.workItemId);
-    await fs.mkdir(root, { recursive: true });
-    const artifactPath = path.join(root, decomposeGateFileNames[gate]);
-    const reportPath = gate === "decompose_proposal" ? path.join(root, phaseFiles.decompose.reportFileName) : path.join(root, `${gate}.md`);
-    const verdictJson = jsonText(redactedPayload);
-    const report = optionalString(redactedPayload, "report_markdown") ?? `# ${gate.replace(/_/g, " ")}
-
-${optionalString(redactedPayload, "summary") ?? "Decompose gate recorded."}
-`;
-    await writeFileAtomic(artifactPath, verdictJson);
-    await writeFileAtomic(reportPath, report);
-    return {
-        phase: "decompose",
-        workItemId: config.workItemId,
-        ownerType: config.ownerType,
-        ownerId: config.ownerId,
-        repoPath: path.resolve(config.worktreePath),
-        path: artifactPath,
-        reportPath,
-        contentHash: sha256(verdictJson),
-        status,
-        producedBy: config.producedBy ?? "forge-completion-tool"
-    };
-}
 async function writeDraftGateCompletionArtifact(config, gate, toolName, input) {
     const payload = asRecord(input, "Draft completion payload");
     const status = normalizeDraftStatus(optionalString(payload, "status") ?? "pass");
     if (gate === "draft_proposal") {
         const draftJson = asRecord(payload["draft_json"], "draft_json");
-        validateDraftProposalJson(draftJson);
+        for (const key of ["title", "summary", "objective", "planningPacket", "decompositionContext"]) {
+            if (typeof draftJson[key] !== "string" || draftJson[key].trim().length === 0) {
+                throw new Error(`draft_json.${key}: expected non-empty string`);
+            }
+        }
     }
     const redactedPayload = redactSecrets({ ...payload, status, phase: "draft", gate, tool_name: toolName }, config.redactionSecrets ?? []);
     const root = artifactRootFor(config.worktreePath, config.workItemId);
@@ -827,22 +680,6 @@ function normalizeDraftStatus(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "blocked" || normalized === "needs_revision" || normalized === "needs_rework" ? normalized : "pass";
 }
-function validateDraftProposalJson(draftJson) {
-    if (isDecompositionDraftJson(draftJson)) {
-        return;
-    }
-    for (const key of ["title", "summary", "objective", "planningPacket", "decompositionContext"]) {
-        if (typeof draftJson[key] !== "string" || draftJson[key].trim().length === 0) {
-            throw new Error(`draft_json.${key}: expected non-empty string`);
-        }
-    }
-}
-function isDecompositionDraftJson(draftJson) {
-    const summary = draftJson["summary"];
-    return typeof summary === "string"
-        && summary.trim().length > 0
-        && Array.isArray(draftJson["candidates"]);
-}
 export async function writeCompletionArtifact(config, toolName, input) {
     const phase = phaseFromToolName(toolName);
     if (phase !== config.phase) {
@@ -1341,7 +1178,6 @@ export function parseCompletionMcpArgs(argv) {
     let debugCycle = false;
     let architectCycle = false;
     let draftCycle = false;
-    let decomposeCycle = false;
     for (let index = 1; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === "--worktree") {
@@ -1385,9 +1221,6 @@ export function parseCompletionMcpArgs(argv) {
         else if (arg === "--draft-cycle") {
             draftCycle = true;
         }
-        else if (arg === "--decompose-cycle") {
-            decomposeCycle = true;
-        }
         else {
             return { ok: false, error: `Unknown mcp argument: ${arg}` };
         }
@@ -1395,7 +1228,7 @@ export function parseCompletionMcpArgs(argv) {
     if (!worktreePath?.trim() || !workItemId?.trim()) {
         return { ok: false, error: "mcp requires --worktree and --work-item-id." };
     }
-    if ([developCycle, qaCycle, debugCycle, architectCycle, draftCycle, decomposeCycle].filter(Boolean).length > 1) {
+    if ([developCycle, qaCycle, debugCycle, architectCycle, draftCycle].filter(Boolean).length > 1) {
         return { ok: false, error: "mcp accepts only one cycle mode." };
     }
     if (developCycle && !isDevelopCompletionPhase(phase)) {
@@ -1413,9 +1246,6 @@ export function parseCompletionMcpArgs(argv) {
     if (draftCycle && phase !== "draft") {
         return { ok: false, error: "mcp --draft-cycle requires --phase draft." };
     }
-    if (decomposeCycle && phase !== "decompose") {
-        return { ok: false, error: "mcp --decompose-cycle requires --phase decompose." };
-    }
     return {
         ok: true,
         config: {
@@ -1430,8 +1260,7 @@ export function parseCompletionMcpArgs(argv) {
             qaCycle,
             debugCycle,
             architectCycle,
-            draftCycle,
-            decomposeCycle
+            draftCycle
         }
     };
 }
@@ -1606,24 +1435,6 @@ function completionToolNextInstructionForQaGate(completedGate, status, nextGate)
             : `${completedGate} accepted. Continue to ${nextGate}.`;
     return `${prefix} ${qaGateInstruction(nextGate)}`;
 }
-function completionToolNextInstructionForDecomposeGate(completedGate, status, nextGate) {
-    if (status !== "pass") {
-        return `Stay in ${completedGate}, address the recorded blockers/rework, then call ${expectedDecomposeCompletionToolName(completedGate)} again.`;
-    }
-    if (!nextGate) {
-        return "Decompose proposal accepted. Forge has the structured child-item proposal JSON needed to populate the proposal row.";
-    }
-    const nextInstructions = {
-        decompose_subject_intake: "Capture subject/scope, then call forge.complete_decompose_subject_intake.",
-        decompose_context_review: "Review project/repo/dependency context, then call forge.complete_decompose_context_review.",
-        decompose_breakdown_strategy: "Choose safe child boundaries, then call forge.complete_decompose_breakdown_strategy.",
-        decompose_child_items: "Draft child candidates, then call forge.complete_decompose_child_items.",
-        decompose_dependency_graph: "Validate dependency DAG, then call forge.complete_decompose_dependency_graph.",
-        decompose_critic: "Critique the decomposition, then call forge.complete_decompose_critic.",
-        decompose_proposal: "Submit final proposal_json through forge.complete_decompose_proposal."
-    };
-    return `${completedGate} accepted. ${nextInstructions[nextGate]}`;
-}
 function completionToolNextInstructionForDebugGate(completedGate, status, nextGate) {
     if (status !== "pass") {
         return `Stay in ${completedGate}, address the recorded blockers, then call ${expectedDebugCompletionToolName(completedGate)} again.`;
@@ -2887,9 +2698,6 @@ function parseStrictCompletionPhase(value) {
     if (normalized === "draft" || normalized === "drafting" || normalized === "draft_work_order") {
         return "draft";
     }
-    if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
-        return "decompose";
-    }
     return null;
 }
 function normalizeDebugCompletionPhase(value) {
@@ -2964,9 +2772,6 @@ function phaseFromToolName(toolName) {
     if (draftGateFromToolName(toolName)) {
         return "draft";
     }
-    if (decomposeGateFromToolName(toolName)) {
-        return "decompose";
-    }
     const debugGate = debugGateFromToolName(toolName);
     if (debugGate) {
         return debugGate;
@@ -2986,22 +2791,6 @@ function draftGateFromToolName(toolName) {
     }
     return null;
 }
-function decomposeGateFromToolName(toolName) {
-    for (const gate of decomposeCompletionGateOrder) {
-        const base = decomposeGateToolNames[gate];
-        if (toolName === base || toolName === `forge.${base}`) {
-            return gate;
-        }
-    }
-    return null;
-}
-function isDecomposeDispatch(dispatch) {
-    const draftKind = dispatch.draft?.kind?.trim().toLowerCase();
-    return dispatch.execution.lane.trim().toLowerCase() === "decompose"
-        || dispatch.session.lane.trim().toLowerCase() === "decompose"
-        || draftKind === "work_order_decomposition"
-        || draftKind === "feature_decomposition";
-}
 function debugGateFromToolName(toolName) {
     const normalized = toolName.trim().toLowerCase();
     for (const gate of debugCompletionPhaseOrder) {

package/dist/session/provider-cli/provider-cli.service.js

@@ -200,8 +200,7 @@ export class ProcessBackedProviderCliService {
         await fs.mkdir(metadataRoot, { recursive: true });
         await fs.writeFile(path.join(metadataRoot, "draft-input.json"), JSON.stringify(dispatch.draft, null, 2) + "\n", "utf8");
         await fs.writeFile(path.join(metadataRoot, "spec.md"), buildDraftSpec(dispatch), "utf8");
-        const decomposeDraft = isDecomposeDraftDispatch(dispatch);
-        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree: draftWorktree, phase: decomposeDraft ? "decompose" : "draft" });
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree: draftWorktree, phase: "draft" });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: tempDir,
             prompt: buildDraftPrompt(dispatch),
@@ -226,9 +225,7 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: decomposeDraft
-                ? "Forge Decompose completion tools configured for decompose_subject_intake -> decompose_context_review -> decompose_breakdown_strategy -> decompose_child_items -> decompose_dependency_graph -> decompose_critic -> decompose_proposal; provider must call each MCP completion tool before exit."
-                : "Forge Draft completion tools configured for draft_intent -> draft_repo_context -> draft_graph_context -> draft_product_scope -> draft_work_order_plan -> draft_critic -> draft_proposal; provider must call each MCP completion tool before exit.",
+            content: "Forge Draft completion tools configured for draft_intent -> draft_repo_context -> draft_graph_context -> draft_product_scope -> draft_work_order_plan -> draft_critic -> draft_proposal; provider must call each MCP completion tool before exit.",
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
@@ -241,110 +238,65 @@ export class ProcessBackedProviderCliService {
             else {
                 context.signal?.addEventListener("abort", abortProvider, { once: true });
             }
-            try {
-                const runPromise = this.processRunner.run({
-                    command: command.command,
-                    args: command.args,
-                    cwd: tempDir,
-                    env: providerProcessEnv(dispatch)
-                }, {
-                    onStdoutLine: async (line) => {
-                        for (const event of outputState.consume(line)) {
-                            await context.emit(event);
-                        }
-                    }
-                }, providerCancellation.signal);
-                const artifactWaitCancellation = new AbortController();
-                const abortArtifactWait = () => artifactWaitCancellation.abort();
-                if (context.signal?.aborted) {
-                    abortArtifactWait();
-                }
-                else {
-                    context.signal?.addEventListener("abort", abortArtifactWait, { once: true });
-                }
-                const artifactWaitPromise = waitForCompletionArtifact(tempDir, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
-                let result;
-                let earlyProposalArtifact = null;
-                try {
-                    const terminal = await Promise.race([
-                        runPromise.then(value => ({ kind: "process", value })),
-                        artifactWaitPromise.then(value => ({ kind: "artifact", value }))
-                    ]);
-                    artifactWaitCancellation.abort();
-                    await artifactWaitPromise.catch(() => undefined);
-                    if (terminal.kind === "artifact") {
-                        earlyProposalArtifact = terminal.value;
-                        providerCancellation.abort();
-                        result = await runPromise.catch(() => ({ exitCode: 0, stdout: "", stderr: "" }));
-                    }
-                    else {
-                        result = terminal.value;
-                    }
-                }
-                finally {
-                    artifactWaitCancellation.abort();
-                    context.signal?.removeEventListener("abort", abortArtifactWait);
-                }
-                if (result.exitCode !== 0 && !earlyProposalArtifact) {
-                    throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
-                }
-                await context.emit({
-                    role: "runner",
-                    kind: "checkpoint",
-                    content: `Provider CLI Draft completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
-                    eventType: "provider_cli_completed"
-                });
-                await emitProviderUsageEvent(context.emit, dispatch, outputState);
-                if (decomposeDraft) {
-                    await emitDecomposeGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-                    const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "decompose");
-                    if (!proposalArtifact) {
-                        throw new Error("Provider CLI Decompose completed but did not call forge.complete_decompose_proposal.");
-                    }
-                    const proposal = parseJsonLine(proposalArtifact.verdictJson) ?? {};
-                    const proposalJson = proposal["proposal_json"] ?? proposal["decomposition_json"];
-                    if (!proposalJson || typeof proposalJson !== "object" || Array.isArray(proposalJson)) {
-                        throw new Error("Provider CLI Decompose completed but decompose.proposal.json did not contain proposal_json.");
+            const runPromise = this.processRunner.run({
+                command: command.command,
+                args: command.args,
+                cwd: tempDir,
+                env: providerProcessEnv(dispatch)
+            }, {
+                onStdoutLine: async (line) => {
+                    for (const event of outputState.consume(line)) {
+                        await context.emit(event);
                     }
-                    const json = JSON.stringify(proposalJson);
-                    await context.emit({
-                        role: "assistant",
-                        kind: "message",
-                        content: json,
-                        eventType: "decompose_proposal"
-                    });
-                    return {
-                        summary: "Decomposition proposal generated through Forge Decompose completion cycle.",
-                        artifact: proposalArtifact,
-                        artifacts: [proposalArtifact]
-                    };
-                }
-                await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-                const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
-                if (!proposalArtifact) {
-                    throw new Error("Provider CLI Draft completed but did not call forge.complete_draft_proposal.");
                 }
-                const proposal = parseJsonLine(proposalArtifact.verdictJson) ?? {};
-                const draftJson = proposal["draft_json"];
-                if (!draftJson || typeof draftJson !== "object" || Array.isArray(draftJson)) {
-                    throw new Error("Provider CLI Draft completed but draft.proposal.json did not contain draft_json.");
-                }
-                const json = JSON.stringify(draftJson);
-                await context.emit({
-                    role: "assistant",
-                    kind: "message",
-                    content: json,
-                    eventType: "draft_complete"
-                });
-                return {
-                    summary: "Draft generated through Forge Draft completion cycle.",
-                    artifact: proposalArtifact,
-                    artifacts: [proposalArtifact]
-                };
+            }, providerCancellation.signal);
+            let result;
+            let earlyProposalArtifact = null;
+            const terminal = await Promise.race([
+                runPromise.then(value => ({ kind: "process", value })),
+                waitForDraftProposalArtifact(tempDir, dispatch.workItem.id, context.signal).then(value => ({ kind: "artifact", value }))
+            ]);
+            if (terminal.kind === "artifact") {
+                earlyProposalArtifact = terminal.value;
+                providerCancellation.abort();
+                result = await runPromise.catch(() => ({ exitCode: 0, stdout: "", stderr: "" }));
+            }
+            else {
+                result = terminal.value;
+            }
+            context.signal?.removeEventListener("abort", abortProvider);
+            if (result.exitCode !== 0 && !earlyProposalArtifact) {
+                throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
+            }
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: `Provider CLI Draft completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
+                eventType: "provider_cli_completed"
+            });
+            await emitProviderUsageEvent(context.emit, dispatch, outputState);
+            await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
+            const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
+            if (!proposalArtifact) {
+                throw new Error("Provider CLI Draft completed but did not call forge.complete_draft_proposal.");
             }
-            finally {
-                context.signal?.removeEventListener("abort", abortProvider);
+            const proposal = parseJsonLine(proposalArtifact.verdictJson) ?? {};
+            const draftJson = proposal["draft_json"];
+            if (!draftJson || typeof draftJson !== "object" || Array.isArray(draftJson)) {
+                throw new Error("Provider CLI Draft completed but draft.proposal.json did not contain draft_json.");
             }
+            const json = JSON.stringify(draftJson);
+            await context.emit({
+                role: "assistant",
+                kind: "message",
+                content: json,
+                eventType: "draft_complete"
+            });
+            return {
+                summary: "Draft generated through Forge Draft completion cycle.",
+                artifact: proposalArtifact,
+                artifacts: [proposalArtifact]
+            };
         }
         finally {
             await cleanupCompletionTools(completionTools, context.emit);
@@ -2083,47 +2035,6 @@ async function emitDraftGateArtifacts(emit, worktreePath, workItemId) {
         }
     }
 }
-async function emitDecomposeGateArtifacts(emit, worktreePath, workItemId) {
-    const decomposeArtifactFiles = {
-        decompose_subject_intake: "decompose.subject-intake.json",
-        decompose_context_review: "decompose.context-review.json",
-        decompose_breakdown_strategy: "decompose.breakdown-strategy.json",
-        decompose_child_items: "decompose.child-items.json",
-        decompose_dependency_graph: "decompose.dependency-graph.json",
-        decompose_critic: "decompose.critic.json",
-        decompose_proposal: "decompose.proposal.json"
-    };
-    const gates = Object.keys(decomposeArtifactFiles);
-    for (const gate of gates) {
-        const actualPath = path.join(worktreePath, ".forge", "work-items", workItemId, "artifacts", decomposeArtifactFiles[gate]);
-        if (!await fileExists(actualPath)) {
-            continue;
-        }
-        const relativePath = path.relative(worktreePath, actualPath).split(path.sep).join("/");
-        await emit({
-            role: "tool",
-            kind: "tool_result",
-            content: `Forge Decompose completion tool recorded ${gate} artifact ${relativePath}.`,
-            eventType: "completion_tool_artifact_recorded",
-            data: JSON.stringify({ phase: "decompose", decompose_gate: gate, artifact_relative_paths: [relativePath] })
-        });
-        await emit({
-            role: "hook",
-            kind: "checkpoint",
-            content: `phase_gate: ${gate} artifact accepted with status pass.`,
-            eventType: "phase_gate"
-        });
-        const next = gates[gates.indexOf(gate) + 1];
-        if (next) {
-            await emit({
-                role: "hook",
-                kind: "checkpoint",
-                content: `phase_progression: ${gate} -> ${next}`,
-                eventType: "phase_gate"
-            });
-        }
-    }
-}
 async function fileExists(filePath) {
     try {
         await fs.access(filePath);
@@ -2138,7 +2049,6 @@ function buildDraftPrompt(dispatch) {
     if (!draft) {
         throw new Error("Draft prompt is missing.");
     }
-    const decomposeDraft = isDecomposeDraftDispatch(dispatch);
     const draftArtifacts = dispatch.artifacts
         .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
         .map((artifact) => `## ${artifact.kind}: ${artifact.slug}\n${artifact.body.trim()}`)
@@ -2157,62 +2067,25 @@ Draft kind: ${draft.kind}
 
 ${draft.userPrompt}
 
-${decomposeDraft
-        ? `Use the injected command/skills/hooks as lane instructions. You must call each Forge Decompose MCP completion tool in order. Do not claim Decompose is complete until forge.complete_decompose_proposal accepts the final proposal_json.
-
-Complete these gates in order: decompose_subject_intake -> decompose_context_review -> decompose_breakdown_strategy -> decompose_child_items -> decompose_dependency_graph -> decompose_critic -> decompose_proposal.
-
-The final proposal_json object must contain summary, optional blockedReason, and candidates.`
-        : `${completionPromptForDraftCycle("draft_intent")}
+${completionPromptForDraftCycle("draft_intent")}
 
-Use the injected command/skills/hooks as lane instructions. You must call each Forge Draft MCP completion tool in order. Do not claim the Draft is complete until forge.complete_draft_proposal accepts the final draft_json.`}
+Use the injected command/skills/hooks as lane instructions. You must call each Forge Draft MCP completion tool in order. Do not claim the Draft is complete until forge.complete_draft_proposal accepts the final draft_json.
 
 Do not modify source files.`;
 }
-function isDecomposeDraftKind(kind) {
-    return kind === "work_order_decomposition" || kind === "feature_decomposition";
-}
-function isDecomposeDraftDispatch(dispatch) {
-    return dispatch.execution.lane.trim().toLowerCase() === "decompose"
-        || dispatch.session.lane.trim().toLowerCase() === "decompose"
-        || isDecomposeDraftKind(dispatch.draft?.kind?.trim().toLowerCase());
-}
 function summarizeStderr(stderr) {
     const trimmed = stderr.trim();
     return trimmed ? `: ${clip(trimmed, 1000)}` : "";
 }
-async function waitForCompletionArtifact(worktreePath, workItemId, phase, signal) {
+async function waitForDraftProposalArtifact(worktreePath, workItemId, signal) {
     while (!signal?.aborted) {
-        const artifact = await readCompletionArtifact(worktreePath, workItemId, phase);
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, "draft");
         if (artifact) {
             return artifact;
         }
-        await delay(1000, signal);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    throw new Error(`${phase} proposal artifact wait was cancelled.`);
-}
-async function delay(ms, signal) {
-    if (!signal) {
-        await new Promise((resolve) => setTimeout(resolve, ms));
-        return;
-    }
-    const abortSignal = signal;
-    if (abortSignal.aborted) {
-        return;
-    }
-    await new Promise((resolve) => {
-        const timeout = setTimeout(done, ms);
-        const abort = () => done();
-        function done() {
-            clearTimeout(timeout);
-            abortSignal.removeEventListener("abort", abort);
-            resolve();
-        }
-        abortSignal.addEventListener("abort", abort, { once: true });
-        if (abortSignal.aborted) {
-            done();
-        }
-    });
+    throw new Error("Draft proposal artifact wait was cancelled.");
 }
 function deterministicDraftPayload(dispatch) {
     const kind = dispatch.draft?.kind ?? "work_item";

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.04a84914da09";
+export declare const forgeBridgeVersion = "0.1.3-dev.f66395c3ac21";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.04a84914da09";
+export const forgeBridgeVersion = "0.1.3-dev.f66395c3ac21";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.3-dev.04a84914da09",
+  "version": "0.1.3-dev.f66395c3ac21",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",