@loucompanion/forge-bridge 0.1.3-dev.62c25087ca89 → 0.1.3-dev.7b1dc795c37f

package/dist/session/phase-completion.schemas.js

@@ -411,7 +411,9 @@ function decomposeGateToolInputSchema(gate, baseProperties) {
             estimatedQaScope: qaScopeSchema("Work Order-to-Feature planning QA estimate. This is not dispatch-authoritative QA scope."),
             estimated_qa_scope: qaScopeSchema("Work Order-to-Feature planning QA estimate. Snake_case alias for estimatedQaScope."),
             qaScope: qaScopeSchema("Feature-to-Story QA scope that becomes Story-level QA scope after proposal approval."),
-            qa_scope: qaScopeSchema("Feature-to-Story QA scope. Snake_case alias for qaScope.")
+            qa_scope: qaScopeSchema("Feature-to-Story QA scope. Snake_case alias for qaScope."),
+            designerRefCandidates: designerRefCandidatesSchema("Designer packet refs that justify this candidate. Omit to inherit all parent refs unchanged."),
+            designer_ref_candidates: designerRefCandidatesSchema("Snake_case alias for designerRefCandidates.")
         }
     };
     const proposalSchema = {
@@ -440,7 +442,27 @@ function decomposeGateToolInputSchema(gate, baseProperties) {
             ...proposalSchema,
             description: "Alias for proposal_json when a client cannot send proposal_json."
         }
-    }, ["status", "summary"], "For the final Decompose proposal, include proposal_json with a candidates array. Work Order-to-Feature candidates may include estimatedQaScope/estimated_qa_scope; Feature-to-Story candidates may include qaScope/qa_scope.");
+    }, ["status", "summary"], "For the final Decompose proposal, include proposal_json with a candidates array. Work Order-to-Feature candidates may include estimatedQaScope/estimated_qa_scope; Feature-to-Story candidates may include qaScope/qa_scope. Both levels may include designerRefCandidates/designer_ref_candidates.");
+}
+function designerRefCandidatesSchema(description) {
+    return {
+        type: "array",
+        description,
+        items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                designerRefId: { type: "string" },
+                designer_ref_id: { type: "string" },
+                refKey: { type: "string" },
+                ref_key: { type: "string" },
+                path: { type: "string" },
+                anchor: { type: "string" },
+                reason: { type: "string" },
+                required: { type: "boolean" }
+            }
+        }
+    };
 }
 function debugToolInputSchema(phase, baseProperties) {
     if (phase === "debug_repro") {

package/dist/session/provider-cli/provider-cli.prompts.d.ts

@@ -16,6 +16,7 @@ export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket,
 export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform): "workspace-write" | "danger-full-access";
 export declare function buildArchitectPrompt(dispatch: RunOnceDispatchPacket): string;
 export declare function architectDependencyInstruction(dispatch: RunOnceDispatchPacket): string;
+export declare function designerRefInstruction(dispatch: RunOnceDispatchPacket): string;
 export declare function architectRevisionInstruction(dispatch: RunOnceDispatchPacket): string;
 export declare function buildImplementationPrompt(dispatch: RunOnceDispatchPacket, phase?: import("../phase-completion.js").CompletionPhase): string;
 export declare function buildDevelopCyclePrompt(dispatch: RunOnceDispatchPacket, phase?: import("../phase-completion.js").CompletionPhase): string;

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

@@ -114,6 +114,7 @@ Read injected Forge context under .forge plus the repository shape, then produce
 Implementation DAG tasks are Develop child tasks only: include focused repo/product implementation changes. Do not create child Develop tasks for parent-story QA, sign-off, materialized child inventory, child-count evidence, parent plan artifact checks, or final integrated acceptance proof; put those checks in qa_plan.final_qa.
 ${architectDependencyInstruction(dispatch)}
 ${architectRevisionInstruction(dispatch)}
+${designerRefInstruction(dispatch)}
 Forge owns protocol files: write Architect artifacts only through the completion MCP tool.
 
 ${completionPromptForPhase("architect")}
@@ -153,6 +154,29 @@ ${dependencies}
 
 Use this predecessor output as foundation. Do not redesign or recreate predecessor scope. If the expected output is unavailable in the checkout/base branch, stop and report dependency_output_unavailable.`;
 }
+export function designerRefInstruction(dispatch) {
+    if (!dispatch.designerRefs || dispatch.designerRefs.refs.length === 0) {
+        return "";
+    }
+    const refs = dispatch.designerRefs.refs
+        .map((attachment, index) => {
+        const ref = attachment.ref;
+        const anchor = ref.anchor ? `#${ref.anchor}` : "";
+        const required = attachment.required ? "required" : "optional";
+        return `${index + 1}. ${ref.refKey} (${ref.kind}, ${required}, ${attachment.lineageKind})
+   - Path: ${ref.path}${anchor}
+   - Hash/commit: ${ref.contentHash} @ ${ref.commitSha}
+   - Reason: ${attachment.reason || "No reason recorded."}`;
+    })
+        .join("\n");
+    return `
+Designer packet context:
+This ${dispatch.designerRefs.ownerType} inherits approved Designer packet refs. Use these refs as implementation planning constraints and cite the relevant paths in tasks when they shape scope.
+
+${refs}
+
+If a required Designer ref is missing or cannot be inspected in the pinned commit/worktree, stop and report design_ref_unavailable instead of inventing replacement behavior.`;
+}
 export function architectRevisionInstruction(dispatch) {
     if (!dispatch.architectRevision) {
         return "";

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

@@ -1,5 +1,4 @@
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import { GitClient } from "../../shared/git/git.js";
 import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
@@ -60,25 +59,18 @@ export class ProcessBackedProviderCliService {
         if (!dispatch.draft) {
             throw new Error("Draft dispatch context is missing.");
         }
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "forge-bridge-draft-"));
-        const draftWorktree = {
-            repoPath: tempDir,
-            worktreePath: tempDir,
-            branchName: "draft",
-            baseBranch: dispatch.cycleRun.baseBranch || dispatch.repo.defaultBranch || "draft",
-            cleanupWorktrees: true
-        };
-        const metadataRoot = path.join(tempDir, ".forge", "work-items", dispatch.workItem.id);
+        const { worktree } = context;
+        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
         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, phase: decomposeDraft ? "decompose" : "draft" });
         const command = buildProviderCliCommand(dispatch, {
-            worktreePath: tempDir,
+            worktreePath: worktree.worktreePath,
             prompt: buildDraftPrompt(dispatch),
             completionTools: completionTools ?? undefined,
-            skipGitRepoCheck: true
+            skipGitRepoCheck: false
         });
         const draftArtifactSlugs = dispatch.artifacts
             .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
@@ -117,7 +109,7 @@ export class ProcessBackedProviderCliService {
                 const runPromise = this.processRunner.run({
                     command: command.command,
                     args: command.args,
-                    cwd: tempDir,
+                    cwd: worktree.worktreePath,
                     env: providerProcessEnv(dispatch)
                 }, {
                     onStdoutLine: async (line) => {
@@ -134,7 +126,7 @@ export class ProcessBackedProviderCliService {
                 else {
                     context.signal?.addEventListener("abort", abortArtifactWait, { once: true });
                 }
-                const artifactWaitPromise = waitForCompletionArtifact(tempDir, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
+                const artifactWaitPromise = waitForCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
                 let result;
                 let earlyProposalArtifact = null;
                 try {
@@ -168,8 +160,8 @@ export class ProcessBackedProviderCliService {
                 });
                 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");
+                    await emitDecomposeGateArtifacts(context.emit, worktree.worktreePath, dispatch.workItem.id);
+                    const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "decompose");
                     if (!proposalArtifact) {
                         throw new Error("Provider CLI Decompose completed but did not call forge.complete_decompose_proposal.");
                     }
@@ -191,8 +183,8 @@ export class ProcessBackedProviderCliService {
                         artifacts: [proposalArtifact]
                     };
                 }
-                await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-                const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
+                await emitDraftGateArtifacts(context.emit, worktree.worktreePath, dispatch.workItem.id);
+                const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "draft");
                 if (!proposalArtifact) {
                     throw new Error("Provider CLI Draft completed but did not call forge.complete_draft_proposal.");
                 }
@@ -220,7 +212,6 @@ export class ProcessBackedProviderCliService {
         }
         finally {
             await cleanupCompletionTools(completionTools, context.emit);
-            await fs.rm(tempDir, { recursive: true, force: true });
         }
     }
     async runImplementation(context) {

package/dist/session/provider-cli/provider-cli.types.d.ts

@@ -8,6 +8,7 @@ export interface ProviderCliRunContext {
 }
 export interface ProviderCliDraftContext {
     readonly dispatch: RunOnceDispatchPacket;
+    readonly worktree: WorktreeHandle;
     readonly signal?: AbortSignal;
     emit(event: RunnerDispatchEvent): Promise<void>;
 }

package/dist/session/session.service.js

@@ -27,23 +27,6 @@ export class BridgeSessionService {
             content: "forge-bridge accepted run-once dispatch.",
             eventType: "dispatch_accepted"
         });
-        if (dispatch.draft) {
-            const run = await this.providerCli.runDraft({
-                dispatch,
-                emit,
-                signal
-            });
-            throwIfAborted(signal);
-            return redactSecrets({
-                schemaVersion: 1,
-                exitCode: 0,
-                summary: run.summary,
-                events,
-                spec: run.spec ?? null,
-                artifact: run.artifact ?? null,
-                artifacts: run.artifacts?.length ? run.artifacts : run.artifact ? [run.artifact] : []
-            }, redactionSecrets);
-        }
         const worktree = await this.worktrees.prepare({
             repo: dispatch.repo,
             workItem: dispatch.workItem,
@@ -71,6 +54,26 @@ export class BridgeSessionService {
             await emitDependencyWarmEvents(worktree.dependencyWarm, emit);
         }
         try {
+            if (dispatch.draft) {
+                throwIfAborted(signal);
+                const run = await this.providerCli.runDraft({
+                    dispatch: providerDispatch,
+                    worktree,
+                    emit,
+                    signal
+                });
+                throwIfAborted(signal);
+                const draftArtifacts = run.artifacts?.length ? run.artifacts : run.artifact ? [run.artifact] : [];
+                return redactSecrets({
+                    schemaVersion: 1,
+                    exitCode: 0,
+                    summary: run.summary,
+                    events,
+                    spec: run.spec ?? null,
+                    artifact: run.artifact ?? null,
+                    artifacts: draftArtifacts
+                }, redactionSecrets);
+            }
             throwIfAborted(signal);
             const lane = dispatch.execution.lane.toLowerCase();
             const role = dispatch.execution.role.toLowerCase();

package/dist/session/session.types.d.ts

@@ -19,6 +19,7 @@ export interface RunOnceDispatchPacket {
     readonly architectDependencies?: DispatchArchitectDependencyContext | null;
     readonly storyDevelop?: DispatchStoryDevelopContext | null;
     readonly storyQa?: DispatchStoryQaContext | null;
+    readonly designerRefs?: DispatchDesignerRefHandoffContext | null;
     readonly draft?: DispatchDraftPrompt | null;
 }
 export interface DispatchDraftPrompt {
@@ -142,6 +143,42 @@ export interface DispatchStoryQaDependencyContext {
     readonly fromWorkItemId: string;
     readonly toWorkItemId: string;
 }
+export interface DispatchDesignerRefHandoffContext {
+    readonly schemaVersion: number;
+    readonly kind: string;
+    readonly ownerType: string;
+    readonly ownerId: string;
+    readonly projectId: string;
+    readonly repoId: string;
+    readonly title: string;
+    readonly refs: readonly DispatchDesignerRefAttachment[];
+}
+export interface DispatchDesignerRefAttachment {
+    readonly ref: DispatchDesignerRef;
+    readonly reason: string;
+    readonly required: boolean;
+    readonly source: string;
+    readonly lineageKind: string;
+    readonly inheritedFromItemType?: string | null;
+    readonly inheritedFromItemId?: string | null;
+    readonly inheritedFromDesignerRefId?: string | null;
+    readonly addedByLane: string;
+    readonly sortOrder: number;
+    readonly createdAt: string;
+}
+export interface DispatchDesignerRef {
+    readonly id: string;
+    readonly projectId: string;
+    readonly repoId: string;
+    readonly refKey: string;
+    readonly kind: string;
+    readonly path: string;
+    readonly anchor?: string | null;
+    readonly title: string;
+    readonly contentHash: string;
+    readonly commitSha: string;
+    readonly createdAt: string;
+}
 export interface DispatchPullRequestContext {
     readonly number: number;
     readonly provider: string;

package/dist/session/session.types.js

@@ -26,6 +26,7 @@ export function parseRunOnceDispatchPacket(value) {
         architectDependencies: parseArchitectDependencies(packet.architectDependencies),
         storyDevelop: parseStoryDevelop(packet.storyDevelop),
         storyQa: parseStoryQa(packet.storyQa),
+        designerRefs: parseDesignerRefs(packet.designerRefs ?? packet.designer_refs),
         draft: parseDraftPrompt(packet.draft)
     };
 }
@@ -416,6 +417,58 @@ function parseStoryQaDependencies(value) {
         };
     });
 }
+function parseDesignerRefs(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const context = asObject(value, "designerRefs");
+    const refs = context.refs;
+    if (!Array.isArray(refs)) {
+        throw new Error("designerRefs.refs must be an array.");
+    }
+    return {
+        schemaVersion: requiredNumber(context, "schemaVersion"),
+        kind: requiredString(context, "kind"),
+        ownerType: requiredString(context, "ownerType"),
+        ownerId: requiredString(context, "ownerId"),
+        projectId: requiredString(context, "projectId"),
+        repoId: requiredString(context, "repoId"),
+        title: requiredString(context, "title"),
+        refs: refs.map((entry, index) => parseDesignerRefAttachment(entry, index))
+    };
+}
+function parseDesignerRefAttachment(value, index) {
+    const attachment = asObject(value, `designerRefs.refs[${index}]`);
+    return {
+        ref: parseDesignerRef(attachment.ref, index),
+        reason: optionalString(attachment, "reason") ?? "",
+        required: requiredBoolean(attachment, "required"),
+        source: optionalString(attachment, "source") ?? "",
+        lineageKind: optionalString(attachment, "lineageKind") ?? optionalString(attachment, "lineage_kind") ?? "",
+        inheritedFromItemType: optionalString(attachment, "inheritedFromItemType") ?? optionalString(attachment, "inherited_from_item_type"),
+        inheritedFromItemId: optionalString(attachment, "inheritedFromItemId") ?? optionalString(attachment, "inherited_from_item_id"),
+        inheritedFromDesignerRefId: optionalString(attachment, "inheritedFromDesignerRefId") ?? optionalString(attachment, "inherited_from_designer_ref_id"),
+        addedByLane: optionalString(attachment, "addedByLane") ?? optionalString(attachment, "added_by_lane") ?? "",
+        sortOrder: requiredNumber(attachment, "sortOrder"),
+        createdAt: requiredString(attachment, "createdAt")
+    };
+}
+function parseDesignerRef(value, index) {
+    const designerRef = asObject(value, `designerRefs.refs[${index}].ref`);
+    return {
+        id: requiredString(designerRef, "id"),
+        projectId: requiredString(designerRef, "projectId"),
+        repoId: requiredString(designerRef, "repoId"),
+        refKey: requiredString(designerRef, "refKey"),
+        kind: requiredString(designerRef, "kind"),
+        path: requiredString(designerRef, "path"),
+        anchor: optionalString(designerRef, "anchor"),
+        title: optionalString(designerRef, "title") ?? "",
+        contentHash: requiredString(designerRef, "contentHash"),
+        commitSha: requiredString(designerRef, "commitSha"),
+        createdAt: requiredString(designerRef, "createdAt")
+    };
+}
 function parseStringArray(value, label) {
     if (!Array.isArray(value)) {
         throw new Error(`${label} must be an array.`);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.62c25087ca89";
+export declare const forgeBridgeVersion = "0.1.3-dev.7b1dc795c37f";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.62c25087ca89";
+export const forgeBridgeVersion = "0.1.3-dev.7b1dc795c37f";

package/package.json

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