@deftai/directive-core 0.55.0

package/dist/swarm/complete-cohort.js

@@ -0,0 +1,407 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { detectLifecycleFolder } from "../scope/decomposed-refs.js";
+import { runTransition } from "../scope/transition.js";
+import { collectChildUris, collectPlanRefs, resolveVbriefRef } from "../scope/vbrief-ref.js";
+import { MAX_FIXPOINT_PASSES, TERMINAL_FOLDERS } from "./constants.js";
+function loadPlan(path) {
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        if (data === null || typeof data !== "object" || Array.isArray(data)) {
+            return null;
+        }
+        const plan = data.plan;
+        return typeof plan === "object" && plan !== null && !Array.isArray(plan)
+            ? plan
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function rel(path, projectRoot) {
+    try {
+        return resolve(path)
+            .slice(resolve(projectRoot).length + 1)
+            .replace(/\\/g, "/");
+    }
+    catch {
+        return resolve(path).replace(/\\/g, "/");
+    }
+}
+function globResolve(pattern, projectRoot) {
+    const absPattern = pattern.startsWith("/") ? pattern : join(projectRoot, pattern);
+    if (!absPattern.includes("*")) {
+        return existsSync(absPattern) ? [resolve(absPattern)] : [];
+    }
+    const slash = absPattern.lastIndexOf("/");
+    const dir = slash >= 0 ? absPattern.slice(0, slash) : projectRoot;
+    const glob = slash >= 0 ? absPattern.slice(slash + 1) : absPattern;
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".vbrief.json") || glob === name)
+        .map((name) => resolve(dir, name))
+        .filter((p) => existsSync(p));
+}
+export function resolveCohortPaths(positional, cohortGlobs, projectRoot) {
+    const resolved = [];
+    const seen = new Set();
+    const errors = [];
+    const add = (path) => {
+        const rp = resolve(path);
+        if (seen.has(rp)) {
+            return;
+        }
+        seen.add(rp);
+        resolved.push(rp);
+    };
+    for (const raw of positional) {
+        const candidate = raw.startsWith("/") ? raw : join(projectRoot, raw);
+        if (!existsSync(candidate)) {
+            errors.push(`path does not exist: ${raw}`);
+            continue;
+        }
+        add(candidate);
+    }
+    for (const pattern of cohortGlobs) {
+        const matched = globResolve(pattern, projectRoot).sort();
+        if (matched.length === 0) {
+            errors.push(`glob matched no files: ${JSON.stringify(pattern)}`);
+            continue;
+        }
+        for (const p of matched) {
+            if (existsSync(p)) {
+                add(p);
+            }
+        }
+    }
+    return { paths: resolved, errors };
+}
+function childIsSettled(childResolved, settled, dryRun, _vbriefDir) {
+    if (dryRun) {
+        return settled.has(childResolved);
+    }
+    const folder = detectLifecycleFolder(childResolved);
+    return (existsSync(childResolved) &&
+        folder !== null &&
+        TERMINAL_FOLDERS.includes(folder));
+}
+function allChildrenSettled(parentPlan, vbriefDir, settled, dryRun) {
+    const childUris = collectChildUris(parentPlan);
+    if (childUris.length === 0) {
+        return false;
+    }
+    for (const uri of childUris) {
+        const childPath = resolveVbriefRef(uri, vbriefDir);
+        if (childPath === null) {
+            return false;
+        }
+        if (!childIsSettled(resolve(childPath), settled, dryRun, vbriefDir)) {
+            return false;
+        }
+    }
+    return true;
+}
+function parentCandidatesFrom(plan, vbriefDir) {
+    const out = [];
+    for (const planRef of collectPlanRefs(plan)) {
+        const parent = resolveVbriefRef(planRef, vbriefDir);
+        if (parent !== null && existsSync(parent)) {
+            out.push(resolve(parent));
+        }
+    }
+    return out;
+}
+function completeStory(storyPath, vbriefDir, projectRoot, settled, dryRun) {
+    const folder = detectLifecycleFolder(storyPath);
+    const relpath = rel(storyPath, projectRoot);
+    if (folder !== null && TERMINAL_FOLDERS.includes(folder)) {
+        settled.add(resolve(storyPath));
+        return {
+            kind: "story",
+            path: relpath,
+            action: "noop",
+            ok: true,
+            detail: `already in ${folder}/`,
+        };
+    }
+    if (folder !== "active") {
+        return {
+            kind: "story",
+            path: relpath,
+            action: "skip",
+            ok: true,
+            detail: `not in active/ (in ${folder ?? "unknown"}/); cohort completion only sweeps active stories`,
+        };
+    }
+    if (dryRun) {
+        settled.add(resolve(storyPath));
+        return {
+            kind: "story",
+            path: relpath,
+            action: "complete",
+            ok: true,
+            detail: "would complete active/ -> completed/",
+        };
+    }
+    const result = runTransition("complete", storyPath);
+    if (result.ok) {
+        settled.add(resolve(join(vbriefDir, "completed", storyPath.split(/[/\\]/).pop() ?? "")));
+    }
+    return {
+        kind: "story",
+        path: relpath,
+        action: result.ok ? "complete" : "failed",
+        ok: result.ok,
+        detail: result.message,
+    };
+}
+function completeParent(parentPath, vbriefDir, projectRoot, settled, dryRun) {
+    const folder = detectLifecycleFolder(parentPath);
+    const relpath = rel(parentPath, projectRoot);
+    if (folder !== null && TERMINAL_FOLDERS.includes(folder)) {
+        settled.add(resolve(parentPath));
+        return {
+            kind: "epic",
+            path: relpath,
+            action: "noop",
+            ok: true,
+            detail: `already in ${folder}/`,
+        };
+    }
+    if (folder === "proposed") {
+        return {
+            kind: "epic",
+            path: relpath,
+            action: "skip",
+            ok: true,
+            detail: "parent in proposed/; promote it before the sweep can complete it",
+        };
+    }
+    if (folder !== "pending" && folder !== "active") {
+        return {
+            kind: "epic",
+            path: relpath,
+            action: "skip",
+            ok: true,
+            detail: `unexpected folder ${folder ?? "unknown"}/`,
+        };
+    }
+    if (dryRun) {
+        settled.add(resolve(parentPath));
+        const action = folder === "pending" ? "activate+complete" : "complete";
+        return {
+            kind: "epic",
+            path: relpath,
+            action,
+            ok: true,
+            detail: `would complete ${folder}/ -> completed/`,
+        };
+    }
+    let current = parentPath;
+    let action = "complete";
+    if (folder === "pending") {
+        action = "activate+complete";
+        const activateResult = runTransition("activate", current);
+        if (!activateResult.ok) {
+            return {
+                kind: "epic",
+                path: relpath,
+                action: "failed",
+                ok: false,
+                detail: `activate failed: ${activateResult.message}`,
+            };
+        }
+        current = join(vbriefDir, "active", parentPath.split(/[/\\]/).pop() ?? "");
+    }
+    const completeResult = runTransition("complete", current);
+    if (completeResult.ok) {
+        settled.add(resolve(join(vbriefDir, "completed", parentPath.split(/[/\\]/).pop() ?? "")));
+    }
+    return {
+        kind: "epic",
+        path: relpath,
+        action: completeResult.ok ? action : "failed",
+        ok: completeResult.ok,
+        detail: completeResult.message,
+    };
+}
+export function sweepCohort(storyPaths, projectRoot, dryRun) {
+    const vbriefDir = join(projectRoot, "vbrief");
+    const result = {
+        project_root: resolve(projectRoot),
+        dry_run: dryRun,
+        stories: [],
+        parents: [],
+        errors: [],
+        ok: true,
+    };
+    const settled = new Set();
+    for (const term of TERMINAL_FOLDERS) {
+        const termDir = join(vbriefDir, term);
+        if (existsSync(termDir)) {
+            for (const name of readdirSync(termDir)) {
+                if (name.endsWith(".vbrief.json")) {
+                    settled.add(resolve(join(termDir, name)));
+                }
+            }
+        }
+    }
+    const parentCandidates = [];
+    const parentSeen = new Set();
+    for (const storyPath of storyPaths) {
+        const plan = loadPlan(storyPath);
+        if (plan !== null) {
+            for (const parent of parentCandidatesFrom(plan, vbriefDir)) {
+                if (!parentSeen.has(parent)) {
+                    parentSeen.add(parent);
+                    parentCandidates.push(parent);
+                }
+            }
+        }
+        result.stories.push(completeStory(storyPath, vbriefDir, projectRoot, settled, dryRun));
+    }
+    const finalized = new Set();
+    let passes = 0;
+    while (passes < MAX_FIXPOINT_PASSES) {
+        passes += 1;
+        let progressed = false;
+        for (const candidate of [...parentCandidates]) {
+            if (finalized.has(candidate)) {
+                continue;
+            }
+            const parentPlan = loadPlan(candidate);
+            if (parentPlan === null) {
+                finalized.add(candidate);
+                continue;
+            }
+            if (!allChildrenSettled(parentPlan, vbriefDir, settled, dryRun)) {
+                continue;
+            }
+            const record = completeParent(candidate, vbriefDir, projectRoot, settled, dryRun);
+            result.parents.push(record);
+            finalized.add(candidate);
+            progressed = true;
+            if (record.ok && (record.action === "complete" || record.action === "activate+complete")) {
+                for (const grandparent of parentCandidatesFrom(parentPlan, vbriefDir)) {
+                    if (!parentSeen.has(grandparent) && !finalized.has(grandparent)) {
+                        parentSeen.add(grandparent);
+                        parentCandidates.push(grandparent);
+                    }
+                }
+            }
+        }
+        if (!progressed) {
+            break;
+        }
+    }
+    result.ok =
+        result.errors.length === 0 && [...result.stories, ...result.parents].every((r) => r.ok);
+    return result;
+}
+export function sweepResultToDict(result) {
+    return {
+        project_root: result.project_root,
+        dry_run: result.dry_run,
+        ok: result.ok,
+        stories: result.stories,
+        parents: result.parents,
+        errors: result.errors,
+    };
+}
+export function renderSweepText(result) {
+    const mode = result.dry_run ? "DRY-RUN" : "sweep";
+    const nStory = result.stories.length;
+    const nEpic = result.parents.length;
+    const lines = [
+        `Swarm cohort completion ${mode} (${nStory} stor${nStory === 1 ? "y" : "ies"}, ${nEpic} epic parent${nEpic === 1 ? "" : "s"})`,
+        `  Project root: ${result.project_root}`,
+    ];
+    if (result.errors.length > 0) {
+        lines.push("  Resolution errors:");
+        for (const err of result.errors) {
+            lines.push(`    - ${err}`);
+        }
+    }
+    if (result.stories.length > 0) {
+        lines.push("  Stories:");
+        for (const r of result.stories) {
+            lines.push(`    [${r.ok ? "ok" : "FAILED"}] ${r.action.padEnd(16)} ${r.path} -- ${r.detail}`);
+        }
+    }
+    if (result.parents.length > 0) {
+        lines.push("  Epic parents:");
+        for (const r of result.parents) {
+            lines.push(`    [${r.ok ? "ok" : "FAILED"}] ${r.action.padEnd(16)} ${r.path} -- ${r.detail}`);
+        }
+    }
+    lines.push("");
+    if (result.ok) {
+        const completed = [...result.stories, ...result.parents].filter((r) => ["complete", "activate+complete"].includes(r.action)).length;
+        const verb = result.dry_run ? "would complete" : "completed";
+        lines.push(`Result: SWEEP CLEAN -- ${verb} ${completed} vBRIEF(s).`);
+    }
+    else {
+        const nFailed = [...result.stories, ...result.parents].filter((r) => !r.ok).length;
+        lines.push(`Result: SWEEP INCOMPLETE -- ${nFailed} transition(s) failed and/or ${result.errors.length} resolution error(s). See above.`);
+    }
+    return lines.join("\n");
+}
+export function completeCohort(args) {
+    const projectRoot = resolve(args.projectRoot);
+    if (!existsSync(projectRoot)) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `Error: project root does not exist: ${projectRoot}\n`,
+        };
+    }
+    if (!existsSync(join(projectRoot, "vbrief"))) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `Error: no vbrief/ directory under project root: ${projectRoot}\n`,
+        };
+    }
+    const { paths, errors } = resolveCohortPaths(args.stories ?? [], args.cohortGlobs ?? [], projectRoot);
+    if (paths.length === 0) {
+        const msg = "Error: empty cohort. Pass one or more story vBRIEF paths as positional arguments and/or --cohort <glob>.";
+        if (args.emitJson) {
+            const empty = {
+                project_root: projectRoot,
+                dry_run: args.dryRun ?? false,
+                stories: [],
+                parents: [],
+                errors: errors.length > 0 ? errors : [msg],
+                ok: false,
+            };
+            return {
+                exitCode: 2,
+                stdout: `${JSON.stringify(sweepResultToDict(empty), null, 2)}\n`,
+                stderr: "",
+            };
+        }
+        let stderr = `${msg}\n`;
+        for (const err of errors) {
+            stderr += `  - ${err}\n`;
+        }
+        return { exitCode: 2, stdout: "", stderr };
+    }
+    const result = sweepCohort(paths, projectRoot, args.dryRun ?? false);
+    result.errors.push(...errors);
+    if (args.emitJson) {
+        return {
+            exitCode: result.ok ? 0 : 1,
+            stdout: `${JSON.stringify(sweepResultToDict(result), null, 2)}\n`,
+            stderr: "",
+        };
+    }
+    return {
+        exitCode: result.ok ? 0 : 1,
+        stdout: `${renderSweepText(result)}\n`,
+        stderr: "",
+    };
+}
+//# sourceMappingURL=complete-cohort.js.map

package/dist/swarm/constants.d.ts

@@ -0,0 +1,18 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_GATE_FAILED = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export declare const EXIT_VALIDATION_ERROR = 1;
+export declare const EXIT_FAILED = 1;
+export declare const EXIT_UNCLEAN = 1;
+export declare const EXIT_EXTERNAL_ERROR = 2;
+export declare const DEFAULT_BASE_BRANCH = "master";
+export declare const LEAF_CODING_WORKER_ROLE = "leaf-implementation";
+export declare const SUBAGENT_BACKEND_SET_CMD = "task policy:subagent-backend -- --set {backend_id}";
+export declare const GATE_ADVISE = "advise";
+export declare const GATE_ENFORCE = "enforce";
+export declare const READY = "ready";
+export declare const LIFECYCLE_FOLDERS: readonly ["proposed", "pending", "active", "completed", "cancelled"];
+export declare const TERMINAL_FOLDERS: readonly ["completed", "cancelled"];
+export declare const C3_FIELDS: readonly ["story_id", "worktree_path", "base_branch"];
+export declare const MAX_FIXPOINT_PASSES = 50;
+//# sourceMappingURL=constants.d.ts.map

package/dist/swarm/constants.js

@@ -0,0 +1,24 @@
+export const EXIT_OK = 0;
+export const EXIT_GATE_FAILED = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const EXIT_VALIDATION_ERROR = 1;
+export const EXIT_FAILED = 1;
+export const EXIT_UNCLEAN = 1;
+export const EXIT_EXTERNAL_ERROR = 2;
+export const DEFAULT_BASE_BRANCH = "master";
+export const LEAF_CODING_WORKER_ROLE = "leaf-implementation";
+export const SUBAGENT_BACKEND_SET_CMD = "task policy:subagent-backend -- --set {backend_id}";
+export const GATE_ADVISE = "advise";
+export const GATE_ENFORCE = "enforce";
+export const READY = "ready";
+export const LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+export const TERMINAL_FOLDERS = ["completed", "cancelled"];
+export const C3_FIELDS = ["story_id", "worktree_path", "base_branch"];
+export const MAX_FIXPOINT_PASSES = 50;
+//# sourceMappingURL=constants.js.map

package/dist/swarm/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./complete-cohort.js";
+export { completeCohortMain } from "./complete-cohort-cli.js";
+export * from "./constants.js";
+export * from "./launch.js";
+export { launchMain, parseLaunchArgv } from "./launch-cli.js";
+export * from "./readiness.js";
+export { readinessMain } from "./readiness-cli.js";
+export * from "./routing.js";
+export { routingSetMain } from "./routing-set-cli.js";
+export * from "./routing-verify.js";
+export { routingVerifyMain } from "./routing-verify-cli.js";
+export * from "./subagent-backend.js";
+export * from "./subprocess.js";
+export * from "./verify-review-clean.js";
+export { verifyReviewCleanMain } from "./verify-review-clean-cli.js";
+export * from "./worktrees.js";
+export { parseWorktreesArgv, worktreesMain } from "./worktrees-cli.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/swarm/index.js

@@ -0,0 +1,18 @@
+export * from "./complete-cohort.js";
+export { completeCohortMain } from "./complete-cohort-cli.js";
+export * from "./constants.js";
+export * from "./launch.js";
+export { launchMain, parseLaunchArgv } from "./launch-cli.js";
+export * from "./readiness.js";
+export { readinessMain } from "./readiness-cli.js";
+export * from "./routing.js";
+export { routingSetMain } from "./routing-set-cli.js";
+export * from "./routing-verify.js";
+export { routingVerifyMain } from "./routing-verify-cli.js";
+export * from "./subagent-backend.js";
+export * from "./subprocess.js";
+export * from "./verify-review-clean.js";
+export { verifyReviewCleanMain } from "./verify-review-clean-cli.js";
+export * from "./worktrees.js";
+export { parseWorktreesArgv, worktreesMain } from "./worktrees-cli.js";
+//# sourceMappingURL=index.js.map

package/dist/swarm/launch-cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { swarmLaunch } from "./launch.js";
+export declare function parseLaunchArgv(argv: readonly string[]): Parameters<typeof swarmLaunch>[0];
+export declare function launchMain(argv?: string[]): number;
+//# sourceMappingURL=launch-cli.d.ts.map

package/dist/swarm/launch-cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { swarmLaunch } from "./launch.js";
+export function parseLaunchArgv(argv) {
+    const stories = [];
+    const paths = [];
+    let group = null;
+    let worktreeMap = null;
+    let baseBranch = "master";
+    let autonomous = false;
+    let allocationPlanId = null;
+    let batchingRationale = null;
+    let operatorApproval = null;
+    let noCreateWorktrees = false;
+    let output = null;
+    let gateClearancesPath = null;
+    let enforceGatesFlag = false;
+    let noAudit = false;
+    let projectRoot = ".";
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        if (arg === "--stories" && next !== undefined) {
+            stories.push(next);
+            i += 1;
+        }
+        else if (arg === "--paths" && next !== undefined) {
+            paths.push(next);
+            i += 1;
+        }
+        else if (arg === "--group" && next !== undefined) {
+            group = next;
+            i += 1;
+        }
+        else if (arg === "--worktree-map" && next !== undefined) {
+            worktreeMap = next;
+            i += 1;
+        }
+        else if (arg === "--base-branch" && next !== undefined) {
+            baseBranch = next;
+            i += 1;
+        }
+        else if (arg === "--autonomous") {
+            autonomous = true;
+        }
+        else if (arg === "--allocation-plan-id" && next !== undefined) {
+            allocationPlanId = next;
+            i += 1;
+        }
+        else if (arg === "--batching-rationale" && next !== undefined) {
+            batchingRationale = next;
+            i += 1;
+        }
+        else if (arg === "--operator-approval" && next !== undefined) {
+            operatorApproval = next;
+            i += 1;
+        }
+        else if (arg === "--no-create-worktrees") {
+            noCreateWorktrees = true;
+        }
+        else if (arg === "--output" && next !== undefined) {
+            output = next;
+            i += 1;
+        }
+        else if (arg === "--gate-clearances" && next !== undefined) {
+            gateClearancesPath = next;
+            i += 1;
+        }
+        else if (arg === "--enforce-gates") {
+            enforceGatesFlag = true;
+        }
+        else if (arg === "--no-audit") {
+            noAudit = true;
+        }
+        else if (arg === "--project-root" && next !== undefined) {
+            projectRoot = next;
+            i += 1;
+        }
+    }
+    return {
+        stories,
+        paths,
+        group,
+        worktreeMap,
+        baseBranch,
+        autonomous,
+        allocationPlanId,
+        batchingRationale,
+        operatorApproval,
+        noCreateWorktrees,
+        output,
+        gateClearancesPath,
+        enforceGatesFlag,
+        noAudit,
+        projectRoot,
+    };
+}
+export function launchMain(argv = process.argv.slice(2)) {
+    const result = swarmLaunch(parseLaunchArgv(argv));
+    if (result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(launchMain());
+}
+//# sourceMappingURL=launch-cli.js.map

package/dist/swarm/launch.d.ts

@@ -0,0 +1,78 @@
+import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
+import { type WorktreeRecord } from "./worktrees.js";
+export interface ResolvedStory {
+    token: string;
+    story_id: string;
+    path: string;
+    relpath: string;
+}
+export type PreflightGateFn = (vbriefPath: string) => {
+    exitCode: number;
+    message: string;
+};
+export type ReadinessGateFn = (vbriefPath: string, projectRoot: string) => {
+    exitCode: number;
+    report: string;
+};
+export type WorktreeResolverFn = (mapping: readonly Record<string, unknown>[], baseBranch: string, createMissing?: boolean, options?: {
+    repoRoot?: string;
+}) => WorktreeRecord[];
+export type RuntimeAuthProbeFn = () => [string, string];
+export declare const defaultPreflightGate: PreflightGateFn;
+export declare const defaultReadinessGate: ReadinessGateFn;
+export declare const defaultRuntimeAuthProbe: RuntimeAuthProbeFn;
+export declare function looksLikePath(token: string): boolean;
+export declare function resolveStories(projectRoot: string, tokens: readonly string[]): {
+    resolved: ResolvedStory[];
+    errors: string[];
+};
+export declare function enforceGates(resolved: readonly ResolvedStory[], projectRoot: string, preflightGate?: PreflightGateFn, readinessGate?: ReadinessGateFn): {
+    story: ResolvedStory;
+    reason: string;
+} | null;
+export declare function buildManifest(resolved: readonly ResolvedStory[], options: {
+    projectRoot: string;
+    group?: string | null;
+    worktreeRecords?: Map<string, WorktreeRecord>;
+    dispatchKind: string;
+    allocationPlanId: string | null;
+    batchingRationale: string | null;
+    operatorApprovalEvidence: string | null;
+    gateClearances?: readonly Record<string, unknown>[];
+    subagentBackend?: string | null;
+    dispatchProvider?: string | null;
+    workerRole?: string | null;
+    resolvedModel?: string | null;
+    modelSource?: string | null;
+    runtimeMode?: string | null;
+    githubAuthMode?: string | null;
+}): Record<string, unknown>[];
+export declare function orderCohort(resolved: readonly ResolvedStory[], _projectRoot: string): ResolvedStory[];
+export interface LaunchArgs {
+    stories?: readonly string[];
+    paths?: readonly string[];
+    group?: string | null;
+    worktreeMap?: string | null;
+    baseBranch?: string;
+    autonomous?: boolean;
+    allocationPlanId?: string | null;
+    batchingRationale?: string | null;
+    operatorApproval?: string | null;
+    noCreateWorktrees?: boolean;
+    output?: string | null;
+    gateClearancesPath?: string | null;
+    enforceGatesFlag?: boolean;
+    noAudit?: boolean;
+    projectRoot?: string;
+    preflightGate?: PreflightGateFn;
+    readinessGate?: ReadinessGateFn;
+    worktreeResolver?: WorktreeResolverFn;
+    runtimeAuthProbe?: RuntimeAuthProbeFn;
+}
+export declare function swarmLaunch(args: LaunchArgs): {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK };
+//# sourceMappingURL=launch.d.ts.map