@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599

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

@@ -0,0 +1,13 @@
+import type { RunOnceDispatchPacket, RunnerDispatchArtifact, RunnerDispatchEvent, RunnerDispatchSpec } from "../session.types.js";
+import type { WorktreeHandle } from "../../worktree/worktree.types.js";
+export interface ProviderCliRunContext {
+    readonly dispatch: RunOnceDispatchPacket;
+    readonly worktree: WorktreeHandle;
+    readonly signal?: AbortSignal;
+    emit(event: RunnerDispatchEvent): Promise<void>;
+}
+export interface ProviderCliRunResult {
+    readonly summary: string;
+    readonly spec?: RunnerDispatchSpec | null;
+    readonly artifact?: RunnerDispatchArtifact | null;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/session/session.base.d.ts

@@ -0,0 +1,7 @@
+import type { RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchEvent } from "./session.types.js";
+export interface SessionEventSink {
+    emit(event: RunnerDispatchEvent): Promise<void>;
+}
+export interface SessionService {
+    runOnce(dispatch: RunOnceDispatchPacket, sink: SessionEventSink, signal?: AbortSignal): Promise<RunOnceResultPacket>;
+}

package/dist/session/session.base.js

@@ -0,0 +1 @@
+export {};

package/dist/session/session.service.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderCliService } from "./provider-cli/provider-cli.base.js";
+import type { SessionEventSink, SessionService } from "./session.base.js";
+import type { RunOnceDispatchPacket, RunOnceResultPacket } from "./session.types.js";
+import type { WorktreeService } from "../worktree/worktree.base.js";
+export declare class BridgeSessionService implements SessionService {
+    private readonly worktrees;
+    private readonly providerCli;
+    constructor(worktrees?: WorktreeService, providerCli?: ProviderCliService);
+    runOnce(dispatch: RunOnceDispatchPacket, sink: SessionEventSink, signal?: AbortSignal): Promise<RunOnceResultPacket>;
+}

package/dist/session/session.service.js

@@ -0,0 +1,134 @@
+import { redactSecrets } from "../shared/redaction/redaction.js";
+import { RoutingProviderCliService } from "./provider-cli/provider-cli.service.js";
+import { GitWorktreeService } from "../worktree/worktree.service.js";
+export class BridgeSessionService {
+    worktrees;
+    providerCli;
+    constructor(worktrees = new GitWorktreeService(), providerCli = new RoutingProviderCliService()) {
+        this.worktrees = worktrees;
+        this.providerCli = providerCli;
+    }
+    async runOnce(dispatch, sink, signal) {
+        validateApiKeySecretGrant(dispatch);
+        const redactionSecrets = exactSecrets(dispatch);
+        const events = [];
+        const emit = async (event) => {
+            throwIfAborted(signal);
+            const redacted = redactSecrets(event, redactionSecrets);
+            events.push(redacted);
+            await sink.emit(redacted);
+        };
+        throwIfAborted(signal);
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: "forge-bridge accepted run-once dispatch.",
+            eventType: "dispatch_accepted"
+        });
+        const worktree = await this.worktrees.prepare({
+            repo: dispatch.repo,
+            workItem: dispatch.workItem,
+            baseBranch: dispatch.cycleRun.baseBranch || dispatch.cycleRun.requestedBase,
+            allowedRepoRoot: dispatch.serverLocal.repoRoot,
+            cleanupWorktrees: dispatch.serverLocal.cleanupWorktrees,
+            artifacts: dispatch.artifacts,
+            warmPathOverrides: dispatch.warmPathOverrides
+        });
+        throwIfAborted(signal);
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Prepared worktree ${worktree.branchName}.`,
+            eventType: "worktree_prepared"
+        });
+        if (worktree.dependencyWarm) {
+            await emitDependencyWarmEvents(worktree.dependencyWarm, emit);
+        }
+        try {
+            throwIfAborted(signal);
+            const lane = dispatch.execution.lane.toLowerCase();
+            const role = dispatch.execution.role.toLowerCase();
+            const isQa = role === "qa" || lane === "qa";
+            const isConflictResolve = role === "conflict_resolve" || lane === "conflict_resolve";
+            const run = isQa
+                ? await this.providerCli.runQa(dispatch, emit, signal)
+                : isConflictResolve
+                    ? await this.providerCli.runConflictResolve({
+                        dispatch,
+                        worktree,
+                        emit,
+                        signal
+                    })
+                    : await this.providerCli.runImplementation({
+                        dispatch,
+                        worktree,
+                        emit,
+                        signal
+                    });
+            return redactSecrets({
+                schemaVersion: 1,
+                exitCode: 0,
+                summary: run.summary,
+                events,
+                spec: run.spec ?? null,
+                artifact: run.artifact ?? null
+            }, redactionSecrets);
+        }
+        finally {
+            await this.worktrees.release(worktree);
+        }
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new Error(String(signal.reason ?? "Dispatch cancelled."));
+    }
+}
+function validateApiKeySecretGrant(dispatch) {
+    if (!dispatch.execution.requiresApiKeySecretGrant) {
+        return;
+    }
+    if (dispatch.execution.authKind !== "api_key") {
+        throw new Error("API-key secret grant requires api_key execution.");
+    }
+    const grant = dispatch.apiKeySecretGrant;
+    if (!grant?.secret) {
+        throw new Error("API-key secret grant is missing.");
+    }
+    if (grant.provider.toLowerCase() !== dispatch.execution.provider.toLowerCase()) {
+        throw new Error("API-key secret grant provider does not match dispatch provider.");
+    }
+    const expiresAt = Date.parse(grant.expiresAt);
+    if (!Number.isFinite(expiresAt) || expiresAt <= Date.now()) {
+        throw new Error("API-key secret grant is expired.");
+    }
+}
+function exactSecrets(dispatch) {
+    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+}
+async function emitDependencyWarmEvents(warm, emit) {
+    if (warm.linked.length > 0) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Warmed dependencies via link: ${warm.linked.join(", ")}.`,
+            eventType: "dependencies_warmed"
+        });
+    }
+    for (const fallback of warm.fallbacks) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Dependency install fallback (${fallback.ecosystem}): ${fallback.reason} Ran \`${fallback.command}\` in ${fallback.packageRoot}.`,
+            eventType: "dependencies_install_fallback"
+        });
+    }
+    if (warm.skipped.length > 0) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Skipped warming missing dependency paths: ${warm.skipped.join(", ")}.`,
+            eventType: "dependencies_warm_skipped"
+        });
+    }
+}

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

@@ -0,0 +1,118 @@
+export interface RunOnceDispatchPacket {
+    readonly schemaVersion: 1;
+    readonly userId: string;
+    readonly workItem: DispatchWorkItem;
+    readonly repo: DispatchRepo;
+    readonly cycleRun: DispatchCycleRun;
+    readonly session: DispatchSession;
+    readonly lease: DispatchLease;
+    readonly execution: DispatchExecution;
+    readonly serverLocal: DispatchServerLocalConfig;
+    readonly apiKeySecretGrant?: ApiKeySecretGrant | null;
+    readonly artifacts: readonly DispatchResolvedArtifact[];
+    readonly warmPathOverrides?: readonly string[];
+}
+export interface DispatchResolvedArtifact {
+    readonly kind: string;
+    readonly slug: string;
+    readonly scope: string;
+    readonly body: string;
+    readonly contentHash: string;
+    readonly lane?: string | null;
+    readonly event?: string | null;
+}
+export interface DispatchWorkItem {
+    readonly id: string;
+    readonly kind: string;
+    readonly title: string;
+    readonly description: string;
+    readonly acceptanceCriteria: string;
+    readonly reproSteps: string;
+    readonly systemInfo: string;
+}
+export interface DispatchRepo {
+    readonly id: string;
+    readonly name: string;
+    readonly remoteUrl: string;
+    readonly defaultBranch: string;
+    readonly cloneOnDemand: boolean;
+    readonly serverLocalPath?: string | null;
+}
+export interface DispatchCycleRun {
+    readonly id: string;
+    readonly kind: string;
+    readonly phase: string;
+    readonly requestedBase: string;
+    readonly baseBranch: string;
+    readonly expectedCurrentBranch?: string | null;
+    readonly attempt: number;
+    readonly model: string;
+}
+export interface DispatchSession {
+    readonly id: string;
+    readonly model: string;
+    readonly lane: string;
+}
+export interface DispatchLease {
+    readonly id: string;
+    readonly worktreeKey: string;
+    readonly lane: string;
+    readonly fencingToken: string;
+    readonly expiresAt: string;
+}
+export interface DispatchExecution {
+    readonly provider: string;
+    readonly model: string;
+    readonly authKind: string;
+    readonly location: string;
+    readonly runnerId?: string | null;
+    readonly repoId: string;
+    readonly role: string;
+    readonly lane: string;
+    readonly requiresApiKeySecretGrant: boolean;
+}
+export interface ApiKeySecretGrant {
+    readonly grantId: string;
+    readonly provider: string;
+    readonly secret: string;
+    readonly expiresAt: string;
+}
+export interface DispatchServerLocalConfig {
+    readonly repoRoot: string;
+    readonly cleanupWorktrees: boolean;
+}
+export interface RunnerDispatchEvent {
+    readonly role: string;
+    readonly kind: string;
+    readonly content: string;
+    readonly eventType: string;
+}
+export interface RunnerDispatchSpec {
+    readonly repoPath: string;
+    readonly path: string;
+    readonly body: string;
+    readonly producedBy: string;
+    readonly status: string;
+}
+export interface RunnerDispatchArtifact {
+    readonly repoPath: string;
+    readonly path: string;
+    readonly verdictJson: string;
+    readonly report: string;
+    readonly producedBy: string;
+    readonly status: string;
+}
+export interface RunOnceResultPacket {
+    readonly schemaVersion: 1;
+    readonly exitCode: number;
+    readonly summary: string;
+    readonly events: readonly RunnerDispatchEvent[];
+    readonly spec?: RunnerDispatchSpec | null;
+    readonly artifact?: RunnerDispatchArtifact | null;
+}
+export interface RunnerEventLine {
+    readonly type: "runner_event";
+    readonly event: RunnerDispatchEvent;
+}
+export declare function parseRunOnceDispatchPacket(value: unknown): RunOnceDispatchPacket;
+export declare function failureResult(summary: string, events?: readonly RunnerDispatchEvent[]): RunOnceResultPacket;

package/dist/session/session.types.js

@@ -0,0 +1,197 @@
+import path from "node:path";
+export function parseRunOnceDispatchPacket(value) {
+    const packet = asObject(value, "dispatch packet");
+    const schemaVersion = requiredNumber(packet, "schemaVersion");
+    if (schemaVersion !== 1) {
+        throw new Error(`Unsupported dispatch schemaVersion: ${schemaVersion}`);
+    }
+    return {
+        schemaVersion: 1,
+        userId: requiredString(packet, "userId"),
+        workItem: parseWorkItem(packet.workItem),
+        repo: parseRepo(packet.repo),
+        cycleRun: parseCycleRun(packet.cycleRun),
+        session: parseSession(packet.session),
+        lease: parseLease(packet.lease),
+        execution: parseExecution(packet.execution),
+        serverLocal: parseServerLocal(packet.serverLocal),
+        apiKeySecretGrant: parseApiKeySecretGrant(packet.apiKeySecretGrant),
+        artifacts: parseArtifacts(packet.artifacts),
+        warmPathOverrides: parseWarmPathOverrides(packet.warmPathOverrides)
+    };
+}
+export function failureResult(summary, events = []) {
+    return {
+        schemaVersion: 1,
+        exitCode: 1,
+        summary,
+        events
+    };
+}
+function parseWorkItem(value) {
+    const item = asObject(value, "workItem");
+    return {
+        id: requiredString(item, "id"),
+        kind: requiredString(item, "kind"),
+        title: requiredString(item, "title"),
+        description: optionalString(item, "description") ?? "",
+        acceptanceCriteria: optionalString(item, "acceptanceCriteria") ?? "",
+        reproSteps: optionalString(item, "reproSteps") ?? "",
+        systemInfo: optionalString(item, "systemInfo") ?? ""
+    };
+}
+function parseRepo(value) {
+    const repo = asObject(value, "repo");
+    return {
+        id: requiredString(repo, "id"),
+        name: requiredString(repo, "name"),
+        remoteUrl: optionalString(repo, "remoteUrl") ?? "",
+        defaultBranch: requiredString(repo, "defaultBranch"),
+        cloneOnDemand: requiredBoolean(repo, "cloneOnDemand"),
+        serverLocalPath: optionalString(repo, "serverLocalPath")
+    };
+}
+function parseCycleRun(value) {
+    const cycle = asObject(value, "cycleRun");
+    return {
+        id: requiredString(cycle, "id"),
+        kind: requiredString(cycle, "kind"),
+        phase: requiredString(cycle, "phase"),
+        requestedBase: optionalString(cycle, "requestedBase") ?? "develop",
+        baseBranch: optionalString(cycle, "baseBranch") ?? "develop",
+        expectedCurrentBranch: optionalString(cycle, "expectedCurrentBranch"),
+        attempt: requiredNumber(cycle, "attempt"),
+        model: requiredString(cycle, "model")
+    };
+}
+function parseSession(value) {
+    const session = asObject(value, "session");
+    return {
+        id: requiredString(session, "id"),
+        model: requiredString(session, "model"),
+        lane: requiredString(session, "lane")
+    };
+}
+function parseLease(value) {
+    const lease = asObject(value, "lease");
+    return {
+        id: requiredString(lease, "id"),
+        worktreeKey: requiredString(lease, "worktreeKey"),
+        lane: requiredString(lease, "lane"),
+        fencingToken: requiredString(lease, "fencingToken"),
+        expiresAt: requiredString(lease, "expiresAt")
+    };
+}
+function parseExecution(value) {
+    const execution = asObject(value, "execution");
+    return {
+        provider: requiredString(execution, "provider"),
+        model: requiredString(execution, "model"),
+        authKind: requiredString(execution, "authKind"),
+        location: requiredString(execution, "location"),
+        runnerId: optionalString(execution, "runnerId"),
+        repoId: requiredString(execution, "repoId"),
+        role: requiredString(execution, "role"),
+        lane: requiredString(execution, "lane"),
+        requiresApiKeySecretGrant: requiredBoolean(execution, "requiresApiKeySecretGrant")
+    };
+}
+function parseApiKeySecretGrant(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const grant = asObject(value, "apiKeySecretGrant");
+    return {
+        grantId: requiredString(grant, "grantId"),
+        provider: requiredString(grant, "provider"),
+        secret: requiredString(grant, "secret"),
+        expiresAt: requiredString(grant, "expiresAt")
+    };
+}
+function parseServerLocal(value) {
+    const serverLocal = asObject(value, "serverLocal");
+    return {
+        repoRoot: requiredString(serverLocal, "repoRoot"),
+        cleanupWorktrees: requiredBoolean(serverLocal, "cleanupWorktrees")
+    };
+}
+function parseWarmPathOverrides(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("warmPathOverrides must be an array when provided.");
+    }
+    return value.map((entry, index) => parseWarmPathOverride(entry, index));
+}
+function parseWarmPathOverride(entry, index) {
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+        throw new Error(`warmPathOverrides[${index}] must be a non-empty string.`);
+    }
+    const trimmed = entry.trim();
+    if (path.isAbsolute(trimmed) || path.posix.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed)) {
+        throw new Error(`warmPathOverrides[${index}] must be a relative path.`);
+    }
+    const segments = trimmed.split(/[\\/]+/).filter(Boolean);
+    if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`warmPathOverrides[${index}] must not contain path traversal.`);
+    }
+    return segments.join("/");
+}
+function parseArtifacts(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("artifacts must be an array when provided.");
+    }
+    return value.map((entry, index) => {
+        const artifact = asObject(entry, `artifacts[${index}]`);
+        return {
+            kind: requiredString(artifact, "kind"),
+            slug: requiredString(artifact, "slug"),
+            scope: requiredString(artifact, "scope"),
+            body: optionalString(artifact, "body") ?? "",
+            contentHash: requiredString(artifact, "contentHash"),
+            lane: optionalString(artifact, "lane"),
+            event: optionalString(artifact, "event")
+        };
+    });
+}
+function asObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function requiredString(source, key) {
+    const value = source[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${key} must be a non-empty string.`);
+    }
+    return value;
+}
+function optionalString(source, key) {
+    const value = source[key];
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${key} must be a string when provided.`);
+    }
+    return value;
+}
+function requiredBoolean(source, key) {
+    const value = source[key];
+    if (typeof value !== "boolean") {
+        throw new Error(`${key} must be a boolean.`);
+    }
+    return value;
+}
+function requiredNumber(source, key) {
+    const value = source[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${key} must be a finite number.`);
+    }
+    return value;
+}

package/dist/shared/git/git.d.ts

@@ -0,0 +1,6 @@
+import { type ProcessRunner } from "../process/process.js";
+export declare class GitClient {
+    private readonly processRunner;
+    constructor(processRunner?: ProcessRunner);
+    run(cwd: string, args: readonly string[]): Promise<string>;
+}

package/dist/shared/git/git.js

@@ -0,0 +1,18 @@
+import { NodeProcessRunner } from "../process/process.js";
+export class GitClient {
+    processRunner;
+    constructor(processRunner = new NodeProcessRunner()) {
+        this.processRunner = processRunner;
+    }
+    async run(cwd, args) {
+        const result = await this.processRunner.run({
+            command: "git",
+            args,
+            cwd
+        });
+        if (result.exitCode !== 0) {
+            throw new Error(`git ${args.join(" ")} failed: ${result.stderr.trim() || result.stdout.trim()}`);
+        }
+        return result.stdout;
+    }
+}

package/dist/shared/path/path.d.ts

@@ -0,0 +1,4 @@
+export declare function isSubPath(root: string, candidate: string): boolean;
+export declare function resolveExistingDirectoryPath(inputPath: string): Promise<string>;
+export declare function ensureDirectory(inputPath: string): Promise<string>;
+export declare function safeSegment(value: string, fallback: string): string;

package/dist/shared/path/path.js

@@ -0,0 +1,29 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export function isSubPath(root, candidate) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
+    const relative = path.relative(normalizedRoot, normalizedCandidate);
+    return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export async function resolveExistingDirectoryPath(inputPath) {
+    const stat = await fs.stat(inputPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`Path is not a directory: ${inputPath}`);
+    }
+    return await fs.realpath(inputPath);
+}
+export async function ensureDirectory(inputPath) {
+    await fs.mkdir(inputPath, { recursive: true });
+    return await resolveExistingDirectoryPath(inputPath);
+}
+export function safeSegment(value, fallback) {
+    const segment = value
+        .trim()
+        .split("")
+        .map((ch) => (/[a-zA-Z0-9_-]/.test(ch) ? ch : "-"))
+        .join("")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    return segment.length > 0 ? segment : fallback;
+}

package/dist/shared/process/process.d.ts

@@ -0,0 +1,16 @@
+export interface ProcessRunRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+}
+export interface ProcessRunResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ProcessRunner {
+    run(request: ProcessRunRequest): Promise<ProcessRunResult>;
+}
+export declare class NodeProcessRunner implements ProcessRunner {
+    run(request: ProcessRunRequest): Promise<ProcessRunResult>;
+}

package/dist/shared/process/process.js

@@ -0,0 +1,32 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+export class NodeProcessRunner {
+    async run(request) {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(request.command, request.args, {
+                cwd: request.cwd,
+                stdio: ["ignore", "pipe", "pipe"]
+            });
+            let stdout = "";
+            let stderr = "";
+            child.on("error", reject);
+            const stdoutReader = readline.createInterface({ input: child.stdout });
+            const stderrReader = readline.createInterface({ input: child.stderr });
+            stdoutReader.on("line", (line) => {
+                stdout += `${line}\n`;
+            });
+            stderrReader.on("line", (line) => {
+                stderr += `${line}\n`;
+            });
+            child.on("close", (code) => {
+                stdoutReader.close();
+                stderrReader.close();
+                resolve({
+                    exitCode: code ?? 1,
+                    stdout,
+                    stderr
+                });
+            });
+        });
+    }
+}

package/dist/shared/redaction/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactSecrets<T>(value: T, exactSecrets?: readonly string[]): T;
+export declare function redactText(value: string, exactSecrets?: readonly string[]): string;

package/dist/shared/redaction/redaction.js

@@ -0,0 +1,30 @@
+const secretKeyPattern = /(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)/i;
+export function redactSecrets(value, exactSecrets = []) {
+    return redactValue(value, exactSecrets);
+}
+export function redactText(value, exactSecrets = []) {
+    let redacted = value;
+    for (const secret of exactSecrets) {
+        if (secret.length > 0) {
+            redacted = redacted.split(secret).join("[REDACTED]");
+        }
+    }
+    return redacted
+        .replace(/(api[_-]?key|authorization|bearer|client[_-]?secret|password|secret|token)(["':=\s]+)([^"',\s]+)/gi, "$1$2[REDACTED]")
+        .replace(/(sk-[a-zA-Z0-9_-]{12,})/g, "[REDACTED]");
+}
+function redactValue(value, exactSecrets) {
+    if (typeof value === "string") {
+        return redactText(value, exactSecrets);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactValue(item, exactSecrets));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        secretKeyPattern.test(key) ? "[REDACTED]" : redactValue(item, exactSecrets)
+    ]));
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const forgeBridgeVersion = "0.1.1-dev.03b8ba168599";

package/dist/version.js

@@ -0,0 +1 @@
+export const forgeBridgeVersion = "0.1.1-dev.03b8ba168599";

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

@@ -0,0 +1,11 @@
+import type { DispatchResolvedArtifact } from "../session/session.types.js";
+export declare function injectWorktreeArtifacts(worktreePath: string, artifacts: readonly DispatchResolvedArtifact[]): Promise<void>;
+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;
+export declare function buildSpecBody(laneCommand: DispatchResolvedArtifact, workItem: {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly acceptanceCriteria: string;
+}): string;