@loucompanion/forge-bridge 0.1.3-dev.04a84914da09 → 0.1.3-dev.09aeeb7ccadf

package/dist/session/session.types.js

@@ -20,10 +20,13 @@ export function parseRunOnceDispatchPacket(value) {
         artifacts: parseArtifacts(packet.artifacts),
         warmPathOverrides: parseWarmPathOverrides(packet.warmPathOverrides),
         qaBrowser: parseQaBrowser(packet.qaBrowser),
+        qaScope: parseQaScope(packet.qaScope ?? packet.qa_scope),
         qaRework: parseQaRework(packet.qaRework),
         architectRevision: parseArchitectRevision(packet.architectRevision),
+        architectDependencies: parseArchitectDependencies(packet.architectDependencies),
         storyDevelop: parseStoryDevelop(packet.storyDevelop),
         storyQa: parseStoryQa(packet.storyQa),
+        designerRefs: parseDesignerRefs(packet.designerRefs ?? packet.designer_refs),
         draft: parseDraftPrompt(packet.draft)
     };
 }
@@ -118,9 +121,45 @@ function parseDraftPrompt(value) {
     return {
         kind: requiredString(draft, "kind"),
         systemPrompt: requiredString(draft, "systemPrompt"),
-        userPrompt: requiredString(draft, "userPrompt")
+        userPrompt: requiredString(draft, "userPrompt"),
+        projectName: optionalString(draft, "projectName"),
+        repoName: optionalString(draft, "repoName"),
+        attachments: parseDraftAttachments(draft.attachments)
     };
 }
+function parseDraftAttachments(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("draft.attachments must be an array when provided.");
+    }
+    return value.map((entry, index) => {
+        const attachment = asObject(entry, `draft.attachments[${index}]`);
+        const kind = requiredString(attachment, "kind").trim().toLowerCase();
+        if (kind !== "text" && kind !== "image") {
+            throw new Error(`draft.attachments[${index}].kind must be text or image.`);
+        }
+        const textContent = optionalString(attachment, "textContent");
+        const contentBase64 = optionalString(attachment, "contentBase64");
+        if (kind === "text" && textContent === null) {
+            throw new Error(`draft.attachments[${index}].textContent is required for text attachments.`);
+        }
+        if (kind === "image" && contentBase64 === null) {
+            throw new Error(`draft.attachments[${index}].contentBase64 is required for image attachments.`);
+        }
+        return {
+            index: optionalNonNegativeInteger(attachment, "index") ?? index,
+            fileName: requiredString(attachment, "fileName"),
+            contentType: optionalString(attachment, "contentType") ?? "",
+            kind,
+            byteCount: optionalNonNegativeInteger(attachment, "byteCount") ?? 0,
+            summary: optionalString(attachment, "summary") ?? "",
+            textContent,
+            contentBase64
+        };
+    });
+}
 function parseApiKeySecretGrant(value) {
     if (value === undefined || value === null) {
         return null;
@@ -197,6 +236,27 @@ function parseQaBrowser(value) {
         missingTargetReason: optionalString(qaBrowser, "missingTargetReason") ?? optionalString(qaBrowser, "missing_target_reason")
     };
 }
+function parseQaScope(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const qaScope = asObject(value, "qaScope");
+    return {
+        schema_version: requiredNumber(qaScope, "schema_version"),
+        surface: parseOptionalStringArray(qaScope.surface, "qaScope.surface"),
+        required_evidence: parseOptionalStringArray(qaScope.required_evidence, "qaScope.required_evidence"),
+        not_applicable: parseOptionalStringArray(qaScope.not_applicable, "qaScope.not_applicable"),
+        browser_required: optionalBoolean(qaScope, "browser_required") ?? optionalBoolean(qaScope, "browserRequired") ?? false,
+        api_required: optionalBoolean(qaScope, "api_required") ?? optionalBoolean(qaScope, "apiRequired") ?? false,
+        source: optionalString(qaScope, "source"),
+        authority: optionalString(qaScope, "authority"),
+        confidence: optionalString(qaScope, "confidence"),
+        confirmed_by_user: optionalBoolean(qaScope, "confirmed_by_user") ?? optionalBoolean(qaScope, "confirmedByUser"),
+        locked: optionalBoolean(qaScope, "locked"),
+        derived_from: parseOptionalObject(qaScope.derived_from ?? qaScope.derivedFrom, "qaScope.derived_from"),
+        rationale: optionalString(qaScope, "rationale")
+    };
+}
 function parseQaAppLaunchTarget(value) {
     if (value === undefined || value === null) {
         return null;
@@ -260,6 +320,34 @@ function parseArchitectRevision(value) {
         feedback: requiredString(revision, "feedback")
     };
 }
+function parseArchitectDependencies(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const context = asObject(value, "architectDependencies");
+    const prerequisites = context.prerequisites;
+    if (!Array.isArray(prerequisites)) {
+        throw new Error("architectDependencies.prerequisites must be an array.");
+    }
+    return {
+        baseBranch: requiredString(context, "baseBranch").trim(),
+        prerequisites: prerequisites.map((entry, index) => {
+            const prerequisite = asObject(entry, `architectDependencies.prerequisites[${index}]`);
+            return {
+                storyId: requiredString(prerequisite, "storyId").trim(),
+                title: requiredString(prerequisite, "title").trim(),
+                scheduleIndex: optionalNonNegativeInteger(prerequisite, "scheduleIndex"),
+                waveIndex: optionalNonNegativeInteger(prerequisite, "waveIndex"),
+                featureScheduleIndex: optionalNonNegativeInteger(prerequisite, "featureScheduleIndex"),
+                expectedOutput: optionalString(prerequisite, "expectedOutput"),
+                handoffSummary: optionalString(prerequisite, "handoffSummary"),
+                dependencyReason: optionalString(prerequisite, "dependencyReason"),
+                pullRequestNumber: optionalPositiveInteger(prerequisite, "pullRequestNumber"),
+                targetBranch: requiredString(prerequisite, "targetBranch").trim()
+            };
+        })
+    };
+}
 function parseStoryDevelop(value) {
     if (value === undefined || value === null) {
         return null;
@@ -365,6 +453,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.`);
@@ -376,6 +516,18 @@ function parseStringArray(value, label) {
         return entry.trim();
     });
 }
+function parseOptionalStringArray(value, label) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    return parseStringArray(value, label);
+}
+function parseOptionalObject(value, label) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return asObject(value, label);
+}
 function parseArtifacts(value) {
     if (value === undefined || value === null) {
         return [];
@@ -447,6 +599,16 @@ function optionalPositiveInteger(source, key) {
     }
     return value;
 }
+function optionalNonNegativeInteger(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${key} must be a non-negative integer when provided.`);
+    }
+    return value;
+}
 function requiredNumber(source, key) {
     const value = source[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {

package/dist/shared/process/windows-launch.d.ts

@@ -0,0 +1,8 @@
+export interface LaunchCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function buildWindowsCmdLaunch(command: string, args: readonly string[], comSpec?: string | undefined): LaunchCommand;
+export declare function buildWindowsLaunchCommand(commandPath: string, args: readonly string[]): LaunchCommand;
+export declare function windowsCommandLine(command: string, args: readonly string[]): string;
+export declare function quoteWindowsCommandLineArg(value: string): string;

package/dist/shared/process/windows-launch.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+export function buildWindowsCmdLaunch(command, args, comSpec = process.env.ComSpec) {
+    const resolvedComSpec = comSpec?.trim();
+    const commandLine = windowsCommandLine(command, args);
+    const cmdPayload = commandLine.startsWith('"') ? `"${commandLine}"` : commandLine;
+    return {
+        command: resolvedComSpec || "cmd.exe",
+        args: ["/d", "/s", "/v:off", "/c", cmdPayload]
+    };
+}
+export function buildWindowsLaunchCommand(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if (extension === ".ps1") {
+        return {
+            command: powershellExecutable(),
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", commandPath, ...args]
+        };
+    }
+    if (extension === ".cmd" || extension === ".bat") {
+        return buildWindowsCmdLaunch(commandPath, args);
+    }
+    return { command: commandPath, args };
+}
+export function windowsCommandLine(command, args) {
+    return [command, ...args].map(quoteWindowsCommandLineArg).join(" ");
+}
+export function quoteWindowsCommandLineArg(value) {
+    const escaped = value
+        .replace(/\^/g, "^^")
+        .replace(/%/g, "^%");
+    if (escaped.length > 0 && !/[\s"&|<>()^%!]/.test(escaped)) {
+        return escaped;
+    }
+    return `"${escaped.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+}
+function powershellExecutable() {
+    const systemRoot = process.env.SystemRoot;
+    return systemRoot
+        ? path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+        : "powershell.exe";
+}

package/dist/shared/provider-capabilities.d.ts

@@ -0,0 +1 @@
+export declare function supportsDraftImageAttachmentsFor(cliProviders: readonly string[]): boolean;

package/dist/shared/provider-capabilities.js

@@ -0,0 +1,3 @@
+export function supportsDraftImageAttachmentsFor(cliProviders) {
+    return cliProviders.some((provider) => provider.trim().toLowerCase() === "codex");
+}

package/dist/shared/redaction/redaction.js

@@ -1,9 +1,11 @@
 const secretKeyPattern = /(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+const attachmentContentKeyPattern = /^(textContent|contentBase64)$/i;
+const serializedAttachmentContentPattern = /("(?:textContent|contentBase64)"\s*:\s*")(?:(?:\\.)|[^"\\])*(")/gi;
 export function redactSecrets(value, exactSecrets = []) {
     return redactValue(value, exactSecrets);
 }
 export function redactText(value, exactSecrets = []) {
-    let redacted = value;
+    let redacted = value.replace(serializedAttachmentContentPattern, "$1[REDACTED]$2");
     for (const secret of exactSecrets) {
         if (secret.length > 0) {
             redacted = redacted.split(secret).join("[REDACTED]");
@@ -25,6 +27,6 @@ function redactValue(value, exactSecrets) {
     }
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [
         key,
-        secretKeyPattern.test(key) ? "[REDACTED]" : redactValue(item, exactSecrets)
+        secretKeyPattern.test(key) || attachmentContentKeyPattern.test(key) ? "[REDACTED]" : redactValue(item, exactSecrets)
     ]));
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.3-dev.04a84914da09";
+export declare const forgeBridgeVersion = "0.1.3-dev.09aeeb7ccadf";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.3-dev.04a84914da09";
+export const forgeBridgeVersion = "0.1.3-dev.09aeeb7ccadf";

package/dist/worktree/artifact-injector.js

@@ -36,19 +36,29 @@ const DRAFT_OPERATIONAL_SKILLS = new Set([
     "draft-repo-context",
     "draft-graph-context",
     "draft-product-scope",
-    "draft-work-order-plan",
     "draft-critic",
     "draft-proposal"
 ]);
+const DRAFT_WORK_ITEM_OPERATIONAL_SKILLS = new Set([
+    "draft-work-item-plan"
+]);
+const DRAFT_WORK_ORDER_OPERATIONAL_SKILLS = new Set([
+    "draft-work-order-plan"
+]);
 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"
 ]);
+const DRAFT_WORK_ITEM_OPERATIONAL_HOOKS = new Set([
+    "draft-work-item-plan"
+]);
+const DRAFT_WORK_ORDER_OPERATIONAL_HOOKS = new Set([
+    "draft-work-order-plan"
+]);
 export async function injectWorktreeArtifacts(worktreePath, artifacts) {
     for (const artifact of artifacts) {
         await writeArtifact(worktreePath, artifact);
@@ -64,7 +74,7 @@ export function filterArtifactsForLane(artifacts, lane, phase) {
         return artifacts.filter((artifact) => shouldInjectArchitectArtifact(artifact, commandSlug));
     }
     if (normalizedLane === "draft") {
-        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug));
+        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug, phase));
     }
     return artifacts;
 }
@@ -142,7 +152,7 @@ function shouldInjectArchitectArtifact(artifact, commandSlug) {
             return false;
     }
 }
-function shouldInjectDraftArtifact(artifact, commandSlug) {
+function shouldInjectDraftArtifact(artifact, commandSlug, phase) {
     if (artifact.scope.trim().toLowerCase() !== "operational") {
         return false;
     }
@@ -151,13 +161,36 @@ function shouldInjectDraftArtifact(artifact, commandSlug) {
         case "command":
             return slug === commandSlug;
         case "skill":
-            return DRAFT_OPERATIONAL_SKILLS.has(slug);
+            return DRAFT_OPERATIONAL_SKILLS.has(slug) || draftPhaseSkills(phase).has(slug);
         case "hook":
-            return DRAFT_OPERATIONAL_HOOKS.has(slug);
+            return DRAFT_OPERATIONAL_HOOKS.has(slug) || draftPhaseHooks(phase).has(slug);
         default:
             return false;
     }
 }
+function draftPhaseSkills(phase) {
+    switch (normalizeDraftPhase(phase)) {
+        case "work_order":
+            return DRAFT_WORK_ORDER_OPERATIONAL_SKILLS;
+        case "story":
+            return DRAFT_WORK_ITEM_OPERATIONAL_SKILLS;
+        default:
+            return DRAFT_WORK_ITEM_OPERATIONAL_SKILLS;
+    }
+}
+function draftPhaseHooks(phase) {
+    switch (normalizeDraftPhase(phase)) {
+        case "work_order":
+            return DRAFT_WORK_ORDER_OPERATIONAL_HOOKS;
+        case "story":
+            return DRAFT_WORK_ITEM_OPERATIONAL_HOOKS;
+        default:
+            return DRAFT_WORK_ITEM_OPERATIONAL_HOOKS;
+    }
+}
+function normalizeDraftPhase(phase) {
+    return phase.trim().toLowerCase().replaceAll("-", "_");
+}
 export function buildSpecBody(laneCommand, workItem, phase = "implementation") {
     const prompt = laneCommand.body.replaceAll("{workItemId}", workItem.id);
     return `---

package/dist/worktree/dependency-warmer.d.ts

@@ -30,3 +30,14 @@ export declare function createDirectoryLink(sourcePath: string, targetPath: stri
 export declare function lockfilesDiffer(baseCheckoutPath: string, worktreePath: string, packageRootRelative: string): Promise<boolean>;
 export declare function requiresInstallFallback(entry: WarmPathEntry, baseCheckoutPath: string, worktreePath: string, sourceExists: boolean): Promise<string | null>;
 export declare function declaresNativeModules(packageRootPath: string): Promise<boolean>;
+export interface NpmLaunchOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly execPath?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDir?: string;
+    readonly candidates?: readonly string[];
+}
+export declare function resolveNpmLaunch(args: readonly string[], options?: NpmLaunchOptions): {
+    command: string;
+    args: readonly string[];
+};

package/dist/worktree/dependency-warmer.js

@@ -1,6 +1,9 @@
+import { existsSync, realpathSync } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { NodeProcessRunner } from "../shared/process/process.js";
+import { buildWindowsCmdLaunch } from "../shared/process/windows-launch.js";
 import { isSubPath } from "../shared/path/path.js";
 const SKIP_DIR_NAMES = new Set([
     ".git",
@@ -184,7 +187,8 @@ async function runInstallFallback(entry, worktreePath, reason, executor) {
     if (entry.ecosystem === "node") {
         const lockPath = path.join(cwd, "package-lock.json");
         const args = (await pathExists(lockPath)) ? ["ci"] : ["install"];
-        await executor.run(cwd, "npm", args);
+        const launch = resolveNpmLaunch(args);
+        await executor.run(cwd, launch.command, launch.args);
         return { ecosystem: entry.ecosystem, packageRoot: entry.packageRoot, reason, command: `npm ${args.join(" ")}` };
     }
     if (entry.ecosystem === "python") {
@@ -286,6 +290,46 @@ async function sha256File(filePath) {
     const content = await fs.readFile(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
 }
+export function resolveNpmLaunch(args, options = {}) {
+    const env = options.env ?? process.env;
+    const execPath = options.execPath ?? process.execPath;
+    const npmExecPath = env.npm_execpath;
+    if (npmExecPath) {
+        return { command: execPath, args: [npmExecPath, ...args] };
+    }
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        const comSpec = options.env ? env.ComSpec ?? "cmd.exe" : env.ComSpec;
+        return buildWindowsCmdLaunch("npm.cmd", args, comSpec);
+    }
+    for (const candidate of options.candidates ?? defaultNpmCliCandidates(execPath, options.homeDir ?? os.homedir())) {
+        const resolvedCandidate = tryResolveNpmCandidate(candidate);
+        if (resolvedCandidate) {
+            return { command: execPath, args: [resolvedCandidate, ...args] };
+        }
+    }
+    return { command: "npm", args };
+}
+function tryResolveNpmCandidate(candidate) {
+    try {
+        if (!existsSync(candidate)) {
+            return null;
+        }
+        return realpathSync(candidate);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultNpmCliCandidates(execPath, homeDir) {
+    const candidates = [];
+    const execDir = path.dirname(execPath);
+    if (path.isAbsolute(execDir)) {
+        candidates.push(path.join(execDir, "npm"), path.join(execDir, "npm-cli.js"), path.join(execDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    }
+    candidates.push("/usr/bin/npm", "/usr/local/bin/npm", path.join(homeDir, ".npm-global", "bin", "npm"), path.join(homeDir, ".npm-global", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
+    return candidates;
+}
 const defaultCommandExecutor = {
     async run(cwd, command, args) {
         const result = await defaultProcessRunner.run({ command, cwd, args });

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

@@ -9,7 +9,8 @@ export declare class GitWorktreeService implements WorktreeService {
     private resolveRepoPath;
     private findExistingRepoPath;
     private resolveMatchingRepo;
-    private ensureBaseBranch;
+    private resolveBaseStartPoint;
+    private resetWorktreeToBase;
     private gitRefExists;
     private currentBranch;
     private ensureGitIdentity;

package/dist/worktree/worktree.service.js

@@ -14,7 +14,7 @@ export class GitWorktreeService {
         const baseBranch = normalizeBranchName(request.baseBranch, "develop");
         const repoPath = await this.resolveRepoPath(request.repo, allowedRoot, baseBranch);
         await this.ensureGitIdentity(repoPath);
-        await this.ensureBaseBranch(repoPath, baseBranch);
+        const baseStartPoint = await this.resolveBaseStartPoint(repoPath, baseBranch);
         const shortId = request.workItem.id.replace(/-/g, "").slice(0, 12);
         const kind = safeSegment(request.workItem.kind, "work-item");
         const fallbackWorktreeKey = `${kind}/${shortId}`;
@@ -30,7 +30,7 @@ export class GitWorktreeService {
         const exists = await directoryExists(worktreePath);
         let resolvedWorktreePath;
         if (!exists) {
-            await this.git.run(repoPath, ["worktree", "add", "-B", branchName, worktreePath, baseBranch]);
+            await this.git.run(repoPath, ["worktree", "add", "-B", branchName, worktreePath, baseStartPoint]);
             resolvedWorktreePath = await resolveExistingDirectoryPath(worktreePath);
         }
         else {
@@ -42,6 +42,9 @@ export class GitWorktreeService {
             if (currentBranch !== branchName) {
                 throw new Error(`Existing worktree ${resolvedWorktreePath} is on branch '${currentBranch}', expected '${branchName}'.`);
             }
+            if (shouldResetExistingWorktree(request)) {
+                await this.resetWorktreeToBase(resolvedWorktreePath, baseStartPoint);
+            }
         }
         await this.ensureGitIdentity(resolvedWorktreePath);
         await clearRunArtifactRoots(resolvedWorktreePath, request);
@@ -164,21 +167,27 @@ export class GitWorktreeService {
         const resolved = await resolveExistingDirectoryPath(candidate);
         return isSubPath(allowedRoot, resolved) ? resolved : null;
     }
-    async ensureBaseBranch(repoPath, baseBranch) {
-        if (await this.gitRefExists(repoPath, `refs/heads/${baseBranch}`)) {
-            return;
-        }
+    async resolveBaseStartPoint(repoPath, baseBranch) {
+        const localRef = `refs/heads/${baseBranch}`;
+        const remoteRef = `refs/remotes/origin/${baseBranch}`;
         const origin = await this.git.run(repoPath, ["remote", "get-url", "origin"]).catch(() => "");
-        if (origin.trim().length === 0) {
-            throw new Error(`Base branch '${baseBranch}' was not found in the local checkout.`);
+        if (origin.trim().length > 0) {
+            const fetched = await this.git.run(repoPath, ["fetch", "--prune", "origin"])
+                .then(() => true)
+                .catch(() => false);
+            if (fetched && await this.gitRefExists(repoPath, remoteRef)) {
+                return remoteRef;
+            }
         }
-        await this.git.run(repoPath, ["fetch", "origin", `${baseBranch}:refs/remotes/origin/${baseBranch}`]).catch(() => "");
-        if (await this.gitRefExists(repoPath, `refs/remotes/origin/${baseBranch}`)) {
-            await this.git.run(repoPath, ["branch", baseBranch, `refs/remotes/origin/${baseBranch}`]);
-            return;
+        if (await this.gitRefExists(repoPath, localRef)) {
+            return localRef;
         }
         throw new Error(`Base branch '${baseBranch}' was not found locally or on origin.`);
     }
+    async resetWorktreeToBase(worktreePath, baseStartPoint) {
+        await this.git.run(worktreePath, ["reset", "--hard", baseStartPoint]);
+        await this.git.run(worktreePath, ["clean", "-fd"]);
+    }
     async gitRefExists(repoPath, gitRef) {
         return this.git.run(repoPath, ["show-ref", "--verify", "--quiet", gitRef]).then(() => true).catch(() => false);
     }
@@ -269,6 +278,17 @@ function normalizeOwnerType(value) {
     }
     return null;
 }
+function shouldResetExistingWorktree(request) {
+    const lane = request.lane.trim().toLowerCase();
+    const phase = request.phase.trim().toLowerCase().replace(/-/g, "_");
+    if (lane === "develop" && (phase === "implementation" || phase === "self_review" || phase === "validation")) {
+        return false;
+    }
+    if (lane === "qa" || phase === "qa") {
+        return false;
+    }
+    return true;
+}
 function qaReworkPacketFileName(packetPath) {
     const normalized = packetPath.trim().replace(/\\/g, "/");
     const fileName = normalized.split("/").filter(Boolean).at(-1) ?? "";

package/package.json

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