@loucompanion/forge-bridge 0.1.1-dev.e52b249f07a8 → 0.1.1-dev.f599637d804e

package/dist/session/session.service.js

@@ -13,7 +13,9 @@ export class BridgeSessionService {
         const redactionSecrets = exactSecrets(dispatch);
         const events = [];
         const emit = async (event) => {
-            throwIfAborted(signal);
+            if (signal?.aborted) {
+                return;
+            }
             const redacted = redactSecrets(event, redactionSecrets);
             events.push(redacted);
             await sink.emit(redacted);
@@ -29,11 +31,18 @@ export class BridgeSessionService {
             repo: dispatch.repo,
             workItem: dispatch.workItem,
             baseBranch: dispatch.cycleRun.baseBranch || dispatch.cycleRun.requestedBase,
+            worktreeKey: dispatch.lease.worktreeKey,
+            ownerType: dispatch.cycleRun.ownerType ?? dispatch.lease.ownerType ?? null,
+            ownerId: dispatch.cycleRun.ownerId ?? dispatch.lease.ownerId ?? null,
+            lane: dispatch.execution.lane,
+            phase: dispatch.cycleRun.phase,
             allowedRepoRoot: dispatch.serverLocal.repoRoot,
             cleanupWorktrees: dispatch.serverLocal.cleanupWorktrees,
             artifacts: dispatch.artifacts,
+            qaRework: dispatch.qaRework,
             warmPathOverrides: dispatch.warmPathOverrides
         });
+        const providerDispatch = withPreparedQaReworkPacket(dispatch, worktree.qaReworkPacketPath);
         throwIfAborted(signal);
         await emit({
             role: "runner",
@@ -49,18 +58,22 @@ export class BridgeSessionService {
             const lane = dispatch.execution.lane.toLowerCase();
             const role = dispatch.execution.role.toLowerCase();
             const isQa = role === "qa" || lane === "qa";
+            const isArchitect = role === "architect" || lane === "architect" || dispatch.cycleRun.kind.toLowerCase() === "architect";
             const isConflictResolve = role === "conflict_resolve" || lane === "conflict_resolve";
             const context = {
-                dispatch,
+                dispatch: providerDispatch,
                 worktree,
                 emit,
                 signal
             };
             const run = isQa
                 ? await this.providerCli.runQa(context)
-                : isConflictResolve
-                    ? await this.providerCli.runConflictResolve(context)
-                    : await this.providerCli.runImplementation(context);
+                : isArchitect
+                    ? await this.providerCli.runArchitect(context)
+                    : isConflictResolve
+                        ? await this.providerCli.runConflictResolve(context)
+                        : await this.providerCli.runImplementation(context);
+            throwIfAborted(signal);
             const phaseArtifacts = run.artifacts?.length ? run.artifacts : run.artifact ? [run.artifact] : [];
             return redactSecrets({
                 schemaVersion: 1,
@@ -104,6 +117,18 @@ function validateApiKeySecretGrant(dispatch) {
 function exactSecrets(dispatch) {
     return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
 }
+function withPreparedQaReworkPacket(dispatch, packetPath) {
+    if (!dispatch.qaRework || !packetPath) {
+        return dispatch;
+    }
+    return {
+        ...dispatch,
+        qaRework: {
+            ...dispatch.qaRework,
+            packetPath
+        }
+    };
+}
 async function emitDependencyWarmEvents(warm, emit) {
     if (warm.linked.length > 0) {
         await emit({

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

@@ -8,11 +8,15 @@ export interface RunOnceDispatchPacket {
     readonly lease: DispatchLease;
     readonly execution: DispatchExecution;
     readonly serverLocal: DispatchServerLocalConfig;
+    readonly pullRequest?: DispatchPullRequestContext | null;
     readonly apiKeySecretGrant?: ApiKeySecretGrant | null;
     readonly artifacts: readonly DispatchResolvedArtifact[];
     readonly warmPathOverrides?: readonly string[];
     readonly qaBrowser?: DispatchQaBrowserContext | null;
     readonly qaRework?: DispatchQaReworkContext | null;
+    readonly architectRevision?: DispatchArchitectRevisionContext | null;
+    readonly storyDevelop?: DispatchStoryDevelopContext | null;
+    readonly storyQa?: DispatchStoryQaContext | null;
 }
 export interface DispatchQaBrowserContext {
     readonly required: boolean;
@@ -36,6 +40,83 @@ export interface DispatchQaReworkContext {
     readonly findingIds: readonly string[];
     readonly findings: readonly Record<string, unknown>[];
 }
+export interface DispatchArchitectRevisionContext {
+    readonly priorPlanId: string;
+    readonly priorContentHash: string;
+    readonly feedback: string;
+}
+export interface DispatchStoryDevelopContext {
+    readonly storyWorkItemId: string;
+    readonly planId: string;
+    readonly planContentHash: string;
+    readonly architectTaskId: string;
+    readonly phaseId: string;
+    readonly dependencyWorkItemIds: readonly string[];
+}
+export interface DispatchStoryQaContext {
+    readonly storyWorkItemId: string;
+    readonly planId: string;
+    readonly planContentHash: string;
+    readonly worktreeKey: string;
+    readonly branch: string;
+    readonly implementationPlanJson?: string | null;
+    readonly qaPlanJson?: string | null;
+    readonly finalQaChecks: readonly string[];
+    readonly childTasks: readonly DispatchStoryQaChildTaskContext[];
+    readonly dependencies: readonly DispatchStoryQaDependencyContext[];
+}
+export interface DispatchStoryQaChildTaskContext {
+    readonly workItemId: string;
+    readonly title: string;
+    readonly architectTaskId: string;
+    readonly phaseId: string;
+    readonly phaseOrder: number;
+    readonly dependencyWorkItemIds: readonly string[];
+    readonly spec?: DispatchStoryQaChildSpecContext | null;
+    readonly implementationArtifact?: DispatchStoryQaArtifactContext | null;
+    readonly selfReviewArtifact?: DispatchStoryQaArtifactContext | null;
+    readonly validationArtifact?: DispatchStoryQaArtifactContext | null;
+    readonly qaArtifact?: DispatchStoryQaArtifactContext | null;
+}
+export interface DispatchStoryQaChildSpecContext {
+    readonly version: number;
+    readonly status: string;
+    readonly path: string;
+    readonly contentHash: string;
+    readonly body: string;
+}
+export interface DispatchStoryQaArtifactContext {
+    readonly artifactId: string;
+    readonly cycleRunId: string;
+    readonly phase: string;
+    readonly status: string;
+    readonly producedAt: string;
+    readonly path?: string | null;
+    readonly verdictJson?: string | null;
+    readonly evidenceJson?: string | null;
+    readonly findingsJson?: string | null;
+    readonly report?: string | null;
+}
+export interface DispatchStoryQaDependencyContext {
+    readonly fromWorkItemId: string;
+    readonly toWorkItemId: string;
+}
+export interface DispatchPullRequestContext {
+    readonly number: number;
+    readonly provider: string;
+    readonly title: string;
+    readonly sourceBranch: string;
+    readonly targetBranch: string;
+    readonly url: string;
+    readonly state: string;
+    readonly checkState: string;
+    readonly mergeState: string;
+    readonly requiredChecksPassed: number;
+    readonly requiredChecksTotal: number;
+    readonly unresolvedThreads: number;
+    readonly humanApproved: boolean;
+    readonly hasMergeConflicts: boolean;
+}
 export interface DispatchResolvedArtifact {
     readonly kind: string;
     readonly slug: string;
@@ -134,6 +215,9 @@ export interface RunnerDispatchArtifact {
     readonly repoPath: string;
     readonly path: string;
     readonly verdictJson: string;
+    readonly planJson?: string | null;
+    readonly evidenceJson?: string | null;
+    readonly findingsJson?: string | null;
     readonly report: string;
     readonly producedBy: string;
     readonly status: string;

package/dist/session/session.types.js

@@ -15,11 +15,15 @@ export function parseRunOnceDispatchPacket(value) {
         lease: parseLease(packet.lease),
         execution: parseExecution(packet.execution),
         serverLocal: parseServerLocal(packet.serverLocal),
+        pullRequest: parsePullRequest(packet.pullRequest),
         apiKeySecretGrant: parseApiKeySecretGrant(packet.apiKeySecretGrant),
         artifacts: parseArtifacts(packet.artifacts),
         warmPathOverrides: parseWarmPathOverrides(packet.warmPathOverrides),
         qaBrowser: parseQaBrowser(packet.qaBrowser),
-        qaRework: parseQaRework(packet.qaRework)
+        qaRework: parseQaRework(packet.qaRework),
+        architectRevision: parseArchitectRevision(packet.architectRevision),
+        storyDevelop: parseStoryDevelop(packet.storyDevelop),
+        storyQa: parseStoryQa(packet.storyQa)
     };
 }
 export function failureResult(summary, events = []) {
@@ -124,6 +128,28 @@ function parseServerLocal(value) {
         cleanupWorktrees: requiredBoolean(serverLocal, "cleanupWorktrees")
     };
 }
+function parsePullRequest(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const pullRequest = asObject(value, "pullRequest");
+    return {
+        number: requiredNumber(pullRequest, "number"),
+        provider: requiredString(pullRequest, "provider"),
+        title: optionalString(pullRequest, "title") ?? "",
+        sourceBranch: requiredString(pullRequest, "sourceBranch"),
+        targetBranch: requiredString(pullRequest, "targetBranch"),
+        url: optionalString(pullRequest, "url") ?? "",
+        state: requiredString(pullRequest, "state"),
+        checkState: requiredString(pullRequest, "checkState"),
+        mergeState: requiredString(pullRequest, "mergeState"),
+        requiredChecksPassed: requiredNumber(pullRequest, "requiredChecksPassed"),
+        requiredChecksTotal: requiredNumber(pullRequest, "requiredChecksTotal"),
+        unresolvedThreads: requiredNumber(pullRequest, "unresolvedThreads"),
+        humanApproved: requiredBoolean(pullRequest, "humanApproved"),
+        hasMergeConflicts: requiredBoolean(pullRequest, "hasMergeConflicts")
+    };
+}
 function parseWarmPathOverrides(value) {
     if (value === undefined || value === null) {
         return [];
@@ -211,6 +237,133 @@ function parseQaRework(value) {
         findings: findingsValue.map((entry, index) => asObject(entry, `qaRework.findings[${index}]`))
     };
 }
+function parseArchitectRevision(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const revision = asObject(value, "architectRevision");
+    return {
+        priorPlanId: requiredString(revision, "priorPlanId"),
+        priorContentHash: requiredString(revision, "priorContentHash"),
+        feedback: requiredString(revision, "feedback")
+    };
+}
+function parseStoryDevelop(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const storyDevelop = asObject(value, "storyDevelop");
+    const dependencyWorkItemIds = storyDevelop.dependencyWorkItemIds;
+    if (!Array.isArray(dependencyWorkItemIds)) {
+        throw new Error("storyDevelop.dependencyWorkItemIds must be an array.");
+    }
+    return {
+        storyWorkItemId: requiredString(storyDevelop, "storyWorkItemId"),
+        planId: requiredString(storyDevelop, "planId"),
+        planContentHash: requiredString(storyDevelop, "planContentHash"),
+        architectTaskId: requiredString(storyDevelop, "architectTaskId"),
+        phaseId: requiredString(storyDevelop, "phaseId"),
+        dependencyWorkItemIds: dependencyWorkItemIds.map((entry, index) => {
+            if (typeof entry !== "string" || entry.trim().length === 0) {
+                throw new Error(`storyDevelop.dependencyWorkItemIds[${index}] must be a non-empty string.`);
+            }
+            return entry.trim();
+        })
+    };
+}
+function parseStoryQa(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const storyQa = asObject(value, "storyQa");
+    return {
+        storyWorkItemId: requiredString(storyQa, "storyWorkItemId"),
+        planId: requiredString(storyQa, "planId"),
+        planContentHash: requiredString(storyQa, "planContentHash"),
+        worktreeKey: requiredString(storyQa, "worktreeKey"),
+        branch: requiredString(storyQa, "branch"),
+        implementationPlanJson: optionalString(storyQa, "implementationPlanJson"),
+        qaPlanJson: optionalString(storyQa, "qaPlanJson"),
+        finalQaChecks: parseStringArray(storyQa.finalQaChecks, "storyQa.finalQaChecks"),
+        childTasks: parseStoryQaChildTasks(storyQa.childTasks),
+        dependencies: parseStoryQaDependencies(storyQa.dependencies)
+    };
+}
+function parseStoryQaChildTasks(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("storyQa.childTasks must be an array.");
+    }
+    return value.map((entry, index) => {
+        const child = asObject(entry, `storyQa.childTasks[${index}]`);
+        return {
+            workItemId: requiredString(child, "workItemId"),
+            title: requiredString(child, "title"),
+            architectTaskId: requiredString(child, "architectTaskId"),
+            phaseId: requiredString(child, "phaseId"),
+            phaseOrder: requiredNumber(child, "phaseOrder"),
+            dependencyWorkItemIds: parseStringArray(child.dependencyWorkItemIds, `storyQa.childTasks[${index}].dependencyWorkItemIds`),
+            spec: parseStoryQaSpec(child.spec, `storyQa.childTasks[${index}].spec`),
+            implementationArtifact: parseStoryQaArtifact(child.implementationArtifact, `storyQa.childTasks[${index}].implementationArtifact`),
+            selfReviewArtifact: parseStoryQaArtifact(child.selfReviewArtifact, `storyQa.childTasks[${index}].selfReviewArtifact`),
+            validationArtifact: parseStoryQaArtifact(child.validationArtifact, `storyQa.childTasks[${index}].validationArtifact`),
+            qaArtifact: parseStoryQaArtifact(child.qaArtifact, `storyQa.childTasks[${index}].qaArtifact`)
+        };
+    });
+}
+function parseStoryQaSpec(value, label) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const spec = asObject(value, label);
+    return {
+        version: requiredNumber(spec, "version"),
+        status: requiredString(spec, "status"),
+        path: requiredString(spec, "path"),
+        contentHash: requiredString(spec, "contentHash"),
+        body: requiredString(spec, "body")
+    };
+}
+function parseStoryQaArtifact(value, label) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const artifact = asObject(value, label);
+    return {
+        artifactId: requiredString(artifact, "artifactId"),
+        cycleRunId: requiredString(artifact, "cycleRunId"),
+        phase: requiredString(artifact, "phase"),
+        status: requiredString(artifact, "status"),
+        producedAt: requiredString(artifact, "producedAt"),
+        path: optionalString(artifact, "path"),
+        verdictJson: optionalString(artifact, "verdictJson"),
+        evidenceJson: optionalString(artifact, "evidenceJson"),
+        findingsJson: optionalString(artifact, "findingsJson"),
+        report: optionalString(artifact, "report")
+    };
+}
+function parseStoryQaDependencies(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("storyQa.dependencies must be an array.");
+    }
+    return value.map((entry, index) => {
+        const dependency = asObject(entry, `storyQa.dependencies[${index}]`);
+        return {
+            fromWorkItemId: requiredString(dependency, "fromWorkItemId").trim(),
+            toWorkItemId: requiredString(dependency, "toWorkItemId").trim()
+        };
+    });
+}
+function parseStringArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${label} must be an array.`);
+    }
+    return value.map((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            throw new Error(`${label}[${index}] must be a non-empty string.`);
+        }
+        return entry.trim();
+    });
+}
 function parseArtifacts(value) {
     if (value === undefined || value === null) {
         return [];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.e52b249f07a8";
+export declare const forgeBridgeVersion = "0.1.1-dev.f599637d804e";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.e52b249f07a8";
+export const forgeBridgeVersion = "0.1.1-dev.f599637d804e";

package/dist/worktree/artifact-injector.d.ts

@@ -1,5 +1,6 @@
 import type { DispatchResolvedArtifact } from "../session/session.types.js";
 export declare function injectWorktreeArtifacts(worktreePath: string, artifacts: readonly DispatchResolvedArtifact[]): Promise<void>;
+export declare function filterArtifactsForLane(artifacts: readonly DispatchResolvedArtifact[], lane: string, phase: string): readonly DispatchResolvedArtifact[];
 export declare function writeArtifact(worktreePath: string, artifact: DispatchResolvedArtifact): Promise<void>;
 export declare function selectLaneCommand(artifacts: readonly DispatchResolvedArtifact[], lane: string, phase: string): DispatchResolvedArtifact | undefined;
 export declare function resolveCommandSlug(lane: string, phase: string): string;

package/dist/worktree/artifact-injector.js

@@ -1,11 +1,52 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+const DEBUG_OPERATIONAL_SKILLS = new Set(["debug-repro", "debug-root-cause", "debug-fix", "debug-regression"]);
+const DEBUG_OPERATIONAL_HOOKS = new Set(["debug-gate", "debug-tool-hook", "debug-rework"]);
+const ARCHITECT_OPERATIONAL_SKILLS = new Set([
+    "architect-repo-map",
+    "architect-acceptance-map",
+    "architect-contract-designer",
+    "architect-dag-planner",
+    "architect-test-plan-designer",
+    "architect-risk-review",
+    "architect-integration-strategy",
+    "architect-handoff-writer",
+    "architect-mcp-contract",
+    "architect-semantic-validator"
+]);
+const ARCHITECT_OPERATIONAL_HOOKS = new Set([
+    "architect-preflight",
+    "architect-context",
+    "architect-repo-map",
+    "architect-acceptance-map",
+    "architect-contracts",
+    "architect-plan",
+    "architect-qa-seed",
+    "architect-integration",
+    "architect-mcp-contract",
+    "architect-validate-plan",
+    "architect-risk-gate",
+    "architect-mcp-complete",
+    "architect-complete",
+    "architect-revise"
+]);
 export async function injectWorktreeArtifacts(worktreePath, artifacts) {
     for (const artifact of artifacts) {
         await writeArtifact(worktreePath, artifact);
     }
 }
+export function filterArtifactsForLane(artifacts, lane, phase) {
+    const normalizedLane = lane.trim().toLowerCase();
+    const commandSlug = resolveCommandSlug(lane, phase).toLowerCase();
+    if (normalizedLane === "debug") {
+        return artifacts.filter((artifact) => shouldInjectDebugArtifact(artifact, commandSlug));
+    }
+    if (normalizedLane === "architect") {
+        return artifacts.filter((artifact) => shouldInjectArchitectArtifact(artifact, commandSlug));
+    }
+    return artifacts;
+}
 export async function writeArtifact(worktreePath, artifact) {
     const writtenHash = sha256(artifact.body);
     if (writtenHash !== artifact.contentHash.toLowerCase()) {
@@ -29,11 +70,15 @@ export function selectLaneCommand(artifacts, lane, phase) {
     return artifacts.find((artifact) => normalizedArtifactKind(artifact.kind) === "command" && artifact.slug.trim().toLowerCase() === slug);
 }
 export function resolveCommandSlug(lane, phase) {
+    const normalizedLane = lane.trim().toLowerCase();
+    if (normalizedLane === "debug") {
+        return "debug-prompt";
+    }
     const normalizedPhase = phase.trim().toLowerCase().replace(/-/g, "_");
     if (normalizedPhase === "rework") {
         return "rework-prompt";
     }
-    switch (lane.trim().toLowerCase()) {
+    switch (normalizedLane) {
         case "architect":
             return "architect-prompt";
         case "qa":
@@ -42,6 +87,38 @@ export function resolveCommandSlug(lane, phase) {
             return "dev-prompt";
     }
 }
+function shouldInjectDebugArtifact(artifact, commandSlug) {
+    if (artifact.scope.trim().toLowerCase() !== "operational") {
+        return false;
+    }
+    const slug = artifact.slug.trim().toLowerCase();
+    switch (normalizedArtifactKind(artifact.kind)) {
+        case "command":
+            return slug === commandSlug;
+        case "skill":
+            return DEBUG_OPERATIONAL_SKILLS.has(slug);
+        case "hook":
+            return DEBUG_OPERATIONAL_HOOKS.has(slug);
+        default:
+            return true;
+    }
+}
+function shouldInjectArchitectArtifact(artifact, commandSlug) {
+    if (artifact.scope.trim().toLowerCase() !== "operational") {
+        return false;
+    }
+    const slug = artifact.slug.trim().toLowerCase();
+    switch (normalizedArtifactKind(artifact.kind)) {
+        case "command":
+            return slug === commandSlug;
+        case "skill":
+            return ARCHITECT_OPERATIONAL_SKILLS.has(slug);
+        case "hook":
+            return ARCHITECT_OPERATIONAL_HOOKS.has(slug);
+        default:
+            return false;
+    }
+}
 export function buildSpecBody(laneCommand, workItem, phase = "implementation") {
     const prompt = laneCommand.body.replaceAll("{workItemId}", workItem.id);
     return `---

package/dist/worktree/worktree.service.d.ts

@@ -11,6 +11,7 @@ export declare class GitWorktreeService implements WorktreeService {
     private resolveMatchingRepo;
     private ensureBaseBranch;
     private gitRefExists;
+    private currentBranch;
     private ensureGitIdentity;
 }
 export declare function normalizeBranchName(value: string | null | undefined, fallback: string): string;