@loucompanion/forge-bridge 0.1.1-dev.ac486debe210 → 0.1.1-dev.ac656b52f9c6

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

@@ -6,6 +6,11 @@ export interface ProviderCliRunContext {
     readonly signal?: AbortSignal;
     emit(event: RunnerDispatchEvent): Promise<void>;
 }
+export interface ProviderCliDraftContext {
+    readonly dispatch: RunOnceDispatchPacket;
+    readonly signal?: AbortSignal;
+    emit(event: RunnerDispatchEvent): Promise<void>;
+}
 export interface ProviderCliRunResult {
     readonly summary: string;
     readonly spec?: RunnerDispatchSpec | null;

package/dist/session/qa-sidecar-validation.d.ts

@@ -0,0 +1,3 @@
+export declare function isPathUnderRoot(root: string, target: string): boolean;
+export declare function ensureNoSymbolicLinkPathSegments(root: string, targetDirectory: string, errorMessage: string): Promise<void>;
+export declare function sha256File(filePath: string): Promise<string>;

package/dist/session/qa-sidecar-validation.js

@@ -0,0 +1,44 @@
+import crypto from "node:crypto";
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function isPathUnderRoot(root, target) {
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return Boolean(relative)
+        && relative !== ".."
+        && !relative.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relative);
+}
+export async function ensureNoSymbolicLinkPathSegments(root, targetDirectory, errorMessage) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTargetDirectory = path.resolve(targetDirectory);
+    const relative = path.relative(resolvedRoot, resolvedTargetDirectory);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(errorMessage);
+    }
+    let current = resolvedRoot;
+    const rootStat = await fs.lstat(current);
+    if (rootStat.isSymbolicLink()) {
+        throw new Error(errorMessage);
+    }
+    if (!relative) {
+        return;
+    }
+    for (const segment of relative.split(path.sep)) {
+        if (!segment) {
+            continue;
+        }
+        current = path.join(current, segment);
+        const stat = await fs.lstat(current);
+        if (stat.isSymbolicLink()) {
+            throw new Error(errorMessage);
+        }
+    }
+}
+export async function sha256File(filePath) {
+    const hash = crypto.createHash("sha256");
+    for await (const chunk of createReadStream(filePath)) {
+        hash.update(chunk);
+    }
+    return hash.digest("hex");
+}

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);
@@ -25,15 +27,39 @@ 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,
             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 +75,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 +134,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,9 +8,120 @@ 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;
+    readonly draft?: DispatchDraftPrompt | null;
+}
+export interface DispatchDraftPrompt {
+    readonly kind: string;
+    readonly systemPrompt: string;
+    readonly userPrompt: string;
+}
+export interface DispatchQaBrowserContext {
+    readonly required: boolean;
+    readonly launchTarget?: DispatchQaAppLaunchTarget | null;
+    readonly artifactsPath: string;
+    readonly missingTargetReason?: string | null;
+}
+export interface DispatchQaAppLaunchTarget {
+    readonly url?: string | null;
+    readonly command?: string | null;
+    readonly working_directory?: string | null;
+    readonly ready_url?: string | null;
+    readonly routes: readonly string[];
+    readonly notes?: string | null;
+}
+export interface DispatchQaReworkContext {
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly packetPath: string;
+    readonly packetJson: string;
+    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;
@@ -41,6 +152,9 @@ export interface DispatchRepo {
 }
 export interface DispatchCycleRun {
     readonly id: string;
+    readonly ownerType?: string | null;
+    readonly ownerId?: string | null;
+    readonly workItemId?: string | null;
     readonly kind: string;
     readonly phase: string;
     readonly requestedBase: string;
@@ -56,6 +170,9 @@ export interface DispatchSession {
 }
 export interface DispatchLease {
     readonly id: string;
+    readonly ownerType?: string | null;
+    readonly ownerId?: string | null;
+    readonly workItemId?: string | null;
     readonly worktreeKey: string;
     readonly lane: string;
     readonly fencingToken: string;
@@ -71,6 +188,7 @@ export interface DispatchExecution {
     readonly role: string;
     readonly lane: string;
     readonly requiresApiKeySecretGrant: boolean;
+    readonly runnerRepoLocalPath?: string | null;
 }
 export interface ApiKeySecretGrant {
     readonly grantId: string;
@@ -103,6 +221,11 @@ 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 implementationPlanJson?: string | null;
+    readonly qaPlanJson?: string | null;
     readonly report: string;
     readonly producedBy: string;
     readonly status: string;

package/dist/session/session.types.js

@@ -15,9 +15,16 @@ 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)
+        warmPathOverrides: parseWarmPathOverrides(packet.warmPathOverrides),
+        qaBrowser: parseQaBrowser(packet.qaBrowser),
+        qaRework: parseQaRework(packet.qaRework),
+        architectRevision: parseArchitectRevision(packet.architectRevision),
+        storyDevelop: parseStoryDevelop(packet.storyDevelop),
+        storyQa: parseStoryQa(packet.storyQa),
+        draft: parseDraftPrompt(packet.draft)
     };
 }
 export function failureResult(summary, events = []) {
@@ -55,6 +62,9 @@ function parseCycleRun(value) {
     const cycle = asObject(value, "cycleRun");
     return {
         id: requiredString(cycle, "id"),
+        ownerType: optionalString(cycle, "ownerType"),
+        ownerId: optionalString(cycle, "ownerId"),
+        workItemId: optionalString(cycle, "workItemId"),
         kind: requiredString(cycle, "kind"),
         phase: requiredString(cycle, "phase"),
         requestedBase: optionalString(cycle, "requestedBase") ?? "develop",
@@ -76,6 +86,9 @@ function parseLease(value) {
     const lease = asObject(value, "lease");
     return {
         id: requiredString(lease, "id"),
+        ownerType: optionalString(lease, "ownerType"),
+        ownerId: optionalString(lease, "ownerId"),
+        workItemId: optionalString(lease, "workItemId"),
         worktreeKey: requiredString(lease, "worktreeKey"),
         lane: requiredString(lease, "lane"),
         fencingToken: requiredString(lease, "fencingToken"),
@@ -93,7 +106,19 @@ function parseExecution(value) {
         repoId: requiredString(execution, "repoId"),
         role: requiredString(execution, "role"),
         lane: requiredString(execution, "lane"),
-        requiresApiKeySecretGrant: requiredBoolean(execution, "requiresApiKeySecretGrant")
+        requiresApiKeySecretGrant: requiredBoolean(execution, "requiresApiKeySecretGrant"),
+        runnerRepoLocalPath: optionalString(execution, "runnerRepoLocalPath")
+    };
+}
+function parseDraftPrompt(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const draft = asObject(value, "draft");
+    return {
+        kind: requiredString(draft, "kind"),
+        systemPrompt: requiredString(draft, "systemPrompt"),
+        userPrompt: requiredString(draft, "userPrompt")
     };
 }
 function parseApiKeySecretGrant(value) {
@@ -115,6 +140,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 [];
@@ -138,6 +185,197 @@ function parseWarmPathOverride(entry, index) {
     }
     return segments.join("/");
 }
+function parseQaBrowser(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const qaBrowser = asObject(value, "qaBrowser");
+    return {
+        required: optionalBoolean(qaBrowser, "required") ?? false,
+        launchTarget: parseQaAppLaunchTarget(qaBrowser.launchTarget ?? qaBrowser.launch_target),
+        artifactsPath: optionalString(qaBrowser, "artifactsPath") ?? optionalString(qaBrowser, "artifacts_path") ?? "",
+        missingTargetReason: optionalString(qaBrowser, "missingTargetReason") ?? optionalString(qaBrowser, "missing_target_reason")
+    };
+}
+function parseQaAppLaunchTarget(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const launchTarget = asObject(value, "qaBrowser.launchTarget");
+    const routes = launchTarget.routes;
+    if (routes !== undefined && routes !== null && !Array.isArray(routes)) {
+        throw new Error("qaBrowser.launchTarget.routes must be an array when provided.");
+    }
+    return {
+        url: optionalString(launchTarget, "url"),
+        command: optionalString(launchTarget, "command"),
+        working_directory: optionalString(launchTarget, "working_directory"),
+        ready_url: optionalString(launchTarget, "ready_url"),
+        routes: Array.isArray(routes)
+            ? routes.map((entry, index) => {
+                if (typeof entry !== "string") {
+                    throw new Error(`qaBrowser.launchTarget.routes[${index}] must be a string.`);
+                }
+                return entry;
+            }).filter((entry) => entry.trim().length > 0)
+            : [],
+        notes: optionalString(launchTarget, "notes")
+    };
+}
+function parseQaRework(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const qaRework = asObject(value, "qaRework");
+    const findingIdsValue = qaRework.findingIds;
+    if (!Array.isArray(findingIdsValue)) {
+        throw new Error("qaRework.findingIds must be an array.");
+    }
+    const findingsValue = qaRework.findings;
+    if (!Array.isArray(findingsValue)) {
+        throw new Error("qaRework.findings must be an array.");
+    }
+    return {
+        attempt: requiredNumber(qaRework, "attempt"),
+        maxAttempts: requiredNumber(qaRework, "maxAttempts"),
+        packetPath: requiredString(qaRework, "packetPath"),
+        packetJson: requiredString(qaRework, "packetJson"),
+        findingIds: findingIdsValue.map((entry, index) => {
+            if (typeof entry !== "string" || entry.trim().length === 0) {
+                throw new Error(`qaRework.findingIds[${index}] must be a non-empty string.`);
+            }
+            return entry;
+        }),
+        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 [];
@@ -189,6 +427,16 @@ function requiredBoolean(source, key) {
     }
     return value;
 }
+function optionalBoolean(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${key} must be a boolean when provided.`);
+    }
+    return value;
+}
 function optionalPositiveInteger(source, key) {
     const value = source[key];
     if (value === undefined || value === null) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.ac486debe210";
+export declare const forgeBridgeVersion = "0.1.1-dev.ac656b52f9c6";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.ac486debe210";
+export const forgeBridgeVersion = "0.1.1-dev.ac656b52f9c6";

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;