@loucompanion/forge-bridge 0.1.1-dev.9219f8477b8a → 0.1.1-dev.a7b57476b69b.dirty1

package/dist/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config.test.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { defaultForgeBridgeConfig } from "./config.js";
+describe("defaultForgeBridgeConfig", () => {
+    it("uses a non-phase-numbered repo root", () => {
+        expect(defaultForgeBridgeConfig().defaultRepoRoot).toBe(path.join(os.tmpdir(), "forge-repos"));
+    });
+});

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

@@ -235,7 +235,15 @@ export class ProcessBackedProviderCliService {
         }
         const outputState = createProviderOutputState(dispatch.execution.provider);
         try {
-            const result = await this.processRunner.run({
+            const providerCancellation = new AbortController();
+            const abortProvider = () => providerCancellation.abort();
+            if (context.signal?.aborted) {
+                abortProvider();
+            }
+            else {
+                context.signal?.addEventListener("abort", abortProvider, { once: true });
+            }
+            const runPromise = this.processRunner.run({
                 command: command.command,
                 args: command.args,
                 cwd: tempDir,
@@ -246,8 +254,28 @@ export class ProcessBackedProviderCliService {
                         await context.emit(event);
                     }
                 }
-            }, context.signal);
-            if (result.exitCode !== 0) {
+            }, providerCancellation.signal);
+            let result;
+            let earlyProposalArtifact = null;
+            if (completionTools && !isDecomposePrompt) {
+                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;
+                }
+            }
+            else {
+                result = await runPromise;
+            }
+            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({
@@ -273,7 +301,7 @@ export class ProcessBackedProviderCliService {
                 };
             }
             await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-            const proposalArtifact = await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
+            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.");
             }
@@ -417,6 +445,16 @@ export class ProcessBackedProviderCliService {
     }
     async runArchitect(context) {
         const { dispatch, worktree } = context;
+        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
+        await fs.mkdir(metadataRoot, { recursive: true });
+        const laneCommand = selectLaneCommand(dispatch.artifacts, dispatch.execution.lane, dispatch.cycleRun.phase);
+        if (!laneCommand) {
+            throw new Error(`Lane command for lane '${dispatch.execution.lane}' phase '${dispatch.cycleRun.phase}' was not resolved.`);
+        }
+        const specBody = buildSpecBody(laneCommand, dispatch.workItem, "architect");
+        const specPath = path.join(metadataRoot, "spec.md");
+        await fs.writeFile(specPath, specBody, "utf8");
+        await fs.writeFile(path.join(metadataRoot, "spec.meta.json"), JSON.stringify({ schema_version: 1, status: "pending_approval", produced_by: "forge-lane-command" }) + "\n", "utf8");
         const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "architect" });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
@@ -483,15 +521,13 @@ export class ProcessBackedProviderCliService {
             content: outputState.finalMessage || `${dispatch.execution.provider} CLI produced an Architect plan for ${worktree.branchName}.`,
             eventType: "architect_complete"
         });
-        const specPath = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id, "spec.md");
-        const specBody = await fs.readFile(specPath, "utf8").catch(() => `# ${dispatch.workItem.title}\n\nArchitect plan pending approval.\n`);
         return {
             summary: `${dispatch.execution.provider} CLI Architect plan produced.`,
             spec: {
                 repoPath: worktree.worktreePath,
                 path: specPath,
                 body: specBody,
-                producedBy: `${dispatch.execution.provider}-cli`,
+                producedBy: "forge-lane-command",
                 status: "pending_approval"
             },
             artifact: architectArtifact,
@@ -2072,11 +2108,85 @@ function summarizeStderr(stderr) {
     const trimmed = stderr.trim();
     return trimmed ? `: ${clip(trimmed, 1000)}` : "";
 }
+async function waitForDraftProposalArtifact(worktreePath, workItemId, signal) {
+    while (!signal?.aborted) {
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, "draft");
+        if (artifact) {
+            return artifact;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error("Draft proposal artifact wait was cancelled.");
+}
 function isDecomposeDraftKind(kind) {
     return kind === "work_order_decomposition" || kind === "feature_decomposition";
 }
 function deterministicDraftPayload(dispatch) {
     const kind = dispatch.draft?.kind ?? "work_item";
+    if (kind === "work_order_decomposition") {
+        return {
+            summary: "Fake decompose proposed a Feature DAG for the Work Order.",
+            blockedReason: "",
+            candidates: [
+                {
+                    origin: "agent",
+                    key: "intake-submission",
+                    title: "Customer intake submission",
+                    summary: "Collect, validate, de-duplicate, and confirm incoming customer requests.",
+                    planningPacket: "# Customer intake submission\n\nPlan Stories for request form validation, attachment support, duplicate prevention, and submission confirmation.",
+                    sortOrder: 10,
+                    dependsOn: []
+                },
+                {
+                    origin: "agent",
+                    key: "review-queue",
+                    title: "Reviewer triage queue",
+                    summary: "Provide reviewer triage, assignment, notes, status transitions, and audit trail.",
+                    planningPacket: "# Reviewer triage queue\n\nPlan Stories for queue filtering, assignment, reviewer notes, status changes, and immutable audit trail.",
+                    sortOrder: 20,
+                    dependsOn: ["intake-submission"]
+                }
+            ]
+        };
+    }
+    if (kind === "feature_decomposition") {
+        return {
+            summary: "Fake decompose proposed a Story DAG for the Feature.",
+            blockedReason: "",
+            candidates: [
+                {
+                    origin: "agent",
+                    key: "foundation",
+                    title: "Build the feature foundation",
+                    description: "Create the persistence, API, and UI shell needed by the feature.",
+                    acceptanceCriteria: "Scenario: Foundation exists\nGiven the Feature is selected\nWhen the foundation is delivered\nThen downstream Stories can build on stable contracts",
+                    points: 3,
+                    sortOrder: 10,
+                    dependsOn: []
+                },
+                {
+                    origin: "agent",
+                    key: "workflow-behavior",
+                    title: "Implement the primary workflow behavior",
+                    description: "Implement the main user-visible behavior for the feature after the foundation is ready.",
+                    acceptanceCriteria: "Scenario: Workflow behavior works\nGiven the foundation Story is complete\nWhen the user performs the primary workflow\nThen the expected state change and feedback are visible",
+                    points: 5,
+                    sortOrder: 20,
+                    dependsOn: ["foundation"]
+                },
+                {
+                    origin: "agent",
+                    key: "audit-and-tests",
+                    title: "Add audit coverage and regression tests",
+                    description: "Add audit/evidence behavior and automated regression coverage for the feature.",
+                    acceptanceCriteria: "Scenario: Feature is verifiable\nGiven the workflow behavior is complete\nWhen validation runs\nThen audit evidence and tests cover the expected outcomes",
+                    points: 3,
+                    sortOrder: 30,
+                    dependsOn: ["workflow-behavior"]
+                }
+            ]
+        };
+    }
     if (kind === "work_order") {
         return {
             title: "Deterministic runner Work Order draft",
@@ -2465,11 +2575,11 @@ class CursorStreamJsonState {
         if (type === "assistant") {
             const text = assistantMessageText(event);
             if (text) {
-                this.finalMessage = clip(text, 4000);
+                this.finalMessage = text;
                 return [{
                         role: "assistant",
                         kind: "message",
-                        content: this.finalMessage,
+                        content: clip(text, 4000),
                         eventType: "provider_message"
                     }];
             }
@@ -2503,7 +2613,7 @@ class CursorStreamJsonState {
         if (type === "result" && stringField(event, "subtype") === "success") {
             const result = stringField(event, "result");
             if (result) {
-                this.finalMessage = clip(result, 4000);
+                this.finalMessage = result;
             }
             this.accumulateUsage(event);
         }
@@ -2684,11 +2794,11 @@ class CodexJsonState {
             if (itemType === "agent_message") {
                 const text = stringField(item, "text");
                 if (text) {
-                    this.finalMessage = clip(text, 4000);
+                    this.finalMessage = text;
                     return [{
                             role: "assistant",
                             kind: "message",
-                            content: this.finalMessage,
+                            content: clip(text, 4000),
                             eventType: "provider_message"
                         }];
                 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.9219f8477b8a";
+export declare const forgeBridgeVersion = "0.1.1-dev.a7b57476b69b.dirty1";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.9219f8477b8a";
+export const forgeBridgeVersion = "0.1.1-dev.a7b57476b69b.dirty1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.1-dev.9219f8477b8a",
+  "version": "0.1.1-dev.a7b57476b69b.dirty1",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",