@loucompanion/forge-bridge 0.1.1-dev.32d4dd5874ee → 0.1.1-dev.40fbc494669b

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 [];
@@ -153,6 +391,7 @@ function parseArtifacts(value) {
             scope: requiredString(artifact, "scope"),
             body: optionalString(artifact, "body") ?? "",
             contentHash: requiredString(artifact, "contentHash"),
+            version: optionalPositiveInteger(artifact, "version") ?? 1,
             lane: optionalString(artifact, "lane"),
             event: optionalString(artifact, "event")
         };
@@ -188,6 +427,26 @@ 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) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${key} must be a positive integer when provided.`);
+    }
+    return value;
+}
 function requiredNumber(source, key) {
     const value = source[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.32d4dd5874ee";
+export declare const forgeBridgeVersion = "0.1.1-dev.40fbc494669b";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.32d4dd5874ee";
+export const forgeBridgeVersion = "0.1.1-dev.40fbc494669b";

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,73 @@
 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"
+]);
+const DRAFT_OPERATIONAL_SKILLS = new Set([
+    "draft-intent",
+    "draft-repo-context",
+    "draft-graph-context",
+    "draft-product-scope",
+    "draft-work-order-plan",
+    "draft-critic",
+    "draft-proposal"
+]);
+const DRAFT_OPERATIONAL_HOOKS = new Set([
+    "draft-intent",
+    "draft-repo-context",
+    "draft-graph-context",
+    "draft-product-scope",
+    "draft-work-order-plan",
+    "draft-critic",
+    "draft-proposal"
+]);
 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));
+    }
+    if (normalizedLane === "draft") {
+        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug));
+    }
+    return artifacts;
+}
 export async function writeArtifact(worktreePath, artifact) {
     const writtenHash = sha256(artifact.body);
     if (writtenHash !== artifact.contentHash.toLowerCase()) {
@@ -29,14 +91,17 @@ 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 normalizedPhase = phase.trim().toLowerCase();
-    if (normalizedPhase === "self_review") {
-        return "self-review-prompt";
+    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 "draft":
+            return "draft-prompt";
         case "architect":
             return "architect-prompt";
         case "qa":
@@ -45,6 +110,54 @@ 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;
+    }
+}
+function shouldInjectDraftArtifact(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 DRAFT_OPERATIONAL_SKILLS.has(slug);
+        case "hook":
+            return DRAFT_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;