@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/helpers/autopilot-runtime.js

@@ -0,0 +1,607 @@
+import { chmodSync, createWriteStream, existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { spawn } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { getOrgxPluginConfigDir } from "../../paths.js";
+import { normalizeCodexArgs } from "./autopilot-slice-utils.js";
+export function createAutopilotRuntime(deps) {
+    function hasExplicitCodexSubcommand(args) {
+        const first = (args[0] ?? "").trim();
+        if (!first || first.startsWith("-"))
+            return false;
+        return true;
+    }
+    function envFlag(name, defaultValue) {
+        const raw = (process.env[name] ?? "").trim().toLowerCase();
+        if (!raw)
+            return defaultValue;
+        return !(raw === "0" || raw === "false" || raw === "no" || raw === "off");
+    }
+    function readFirstExisting(paths) {
+        for (const pathname of paths) {
+            if (!pathname)
+                continue;
+            try {
+                if (!existsSync(pathname))
+                    continue;
+                return readFileSync(pathname, "utf8");
+            }
+            catch {
+                // continue
+            }
+        }
+        return null;
+    }
+    function extractOrgxOpenclawUrl(configToml) {
+        if (!configToml)
+            return null;
+        const lines = configToml.split(/\r?\n/);
+        let inTargetSection = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            if (/^\[mcp_servers\.(?:"orgx-openclaw"|orgx-openclaw)\]\s*$/i.test(line)) {
+                inTargetSection = true;
+                continue;
+            }
+            if (inTargetSection && line.startsWith("[")) {
+                break;
+            }
+            if (!inTargetSection)
+                continue;
+            const urlMatch = line.match(/^url\s*=\s*"([^"]+)"\s*$/i);
+            if (!urlMatch)
+                continue;
+            const rawUrl = (urlMatch[1] ?? "").trim();
+            if (rawUrl.length > 0)
+                return rawUrl;
+        }
+        return null;
+    }
+    function prepareAutopilotCodexHome() {
+        const configuredHome = (process.env.ORGX_AUTOPILOT_CODEX_HOME ?? "").trim();
+        const preferredHome = configuredHome.length > 0
+            ? configuredHome
+            : join(getOrgxPluginConfigDir(), "codex-autopilot-home");
+        const sourceHome = (process.env.CODEX_HOME ?? "").trim() || join(homedir(), ".codex");
+        const sourceConfigCandidates = [
+            join(sourceHome, "config.toml"),
+            join(homedir(), ".codex", "config.toml"),
+            join(homedir(), ".config", "codex", "config.toml"),
+        ];
+        const mcpModeRaw = (process.env.ORGX_AUTOPILOT_CODEX_MCP_MODE ?? "").trim().toLowerCase();
+        const mcpMode = mcpModeRaw.length > 0 ? mcpModeRaw : "orgx-openclaw";
+        const sourceConfig = readFirstExisting(sourceConfigCandidates);
+        const extractedOrgxOpenclawUrl = extractOrgxOpenclawUrl(sourceConfig);
+        const defaultOrgxOpenclawUrl = (process.env.ORGX_AUTOPILOT_ORGX_MCP_URL ?? "").trim() ||
+            extractedOrgxOpenclawUrl ||
+            "http://127.0.0.1:18789/orgx/mcp";
+        const configLines = [
+            "# Autogenerated by OrgX autopilot runtime. This isolates codex slices",
+            "# from broken or noisy global MCP entries in ~/.codex/config.toml.",
+            "",
+        ];
+        if (mcpMode === "none") {
+            configLines.push("mcp_servers = {}", "");
+        }
+        else {
+            configLines.push('[mcp_servers."orgx-openclaw"]', `url = ${JSON.stringify(defaultOrgxOpenclawUrl)}`, "");
+        }
+        const writeAutopilotHome = (targetHome) => {
+            try {
+                mkdirSync(targetHome, { recursive: true, mode: 0o700 });
+                try {
+                    chmodSync(targetHome, 0o700);
+                }
+                catch {
+                    // best effort
+                }
+            }
+            catch {
+                return false;
+            }
+            const sourceAuthPath = join(sourceHome, "auth.json");
+            const targetAuthPath = join(targetHome, "auth.json");
+            try {
+                if (existsSync(sourceAuthPath)) {
+                    const authRaw = readFileSync(sourceAuthPath, "utf8");
+                    writeFileSync(targetAuthPath, authRaw, { encoding: "utf8", mode: 0o600 });
+                }
+            }
+            catch {
+                // best effort
+            }
+            try {
+                writeFileSync(join(targetHome, "config.toml"), `${configLines.join("\n")}\n`, {
+                    encoding: "utf8",
+                    mode: 0o600,
+                });
+            }
+            catch {
+                return false;
+            }
+            return true;
+        };
+        if (writeAutopilotHome(preferredHome))
+            return preferredHome;
+        // Hard fallback: use an ephemeral isolated CODEX_HOME so slices do not
+        // inherit potentially broken global MCP config.
+        try {
+            const fallbackHome = mkdtempSync(join(tmpdir(), "orgx-autopilot-codex-home-"));
+            if (writeAutopilotHome(fallbackHome))
+                return fallbackHome;
+        }
+        catch {
+            // best effort
+        }
+        return null;
+    }
+    function ensurePrivateDirForFile(pathname) {
+        const dir = dirname(pathname);
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        try {
+            chmodSync(dir, 0o700);
+        }
+        catch {
+            // best effort
+        }
+    }
+    function hasSliceOutput(pathname) {
+        try {
+            if (!existsSync(pathname))
+                return false;
+            const raw = readFileSync(pathname, "utf8");
+            return raw.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    function writeFallbackSliceOutput(input) {
+        if (hasSliceOutput(input.outputPath))
+            return false;
+        try {
+            writeFileSync(input.outputPath, `${JSON.stringify({
+                status: "error",
+                summary: `Worker exited without structured output (${input.reason}; code=${String(input.code)}, signal=${String(input.signal)}).`,
+                workstream_id: input.workstreamId ?? "unknown",
+                workstream_title: input.workstreamTitle ?? null,
+                slice_id: input.runId,
+            }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function spawnCodexSliceWorker(input) {
+        ensurePrivateDirForFile(input.logPath);
+        ensurePrivateDirForFile(input.outputPath);
+        const workerKind = (process.env.ORGX_AUTOPILOT_WORKER_KIND ?? "").trim().toLowerCase();
+        if (workerKind === "mock") {
+            const scriptPath = resolve(dirname(deps.filename), "..", "..", "scripts", "mock-autopilot-slice-worker.mjs");
+            const logStream = createWriteStream(input.logPath, { flags: "a" });
+            const outStream = createWriteStream(input.outputPath, { flags: "a" });
+            logStream.write(`\n==== ${new Date().toISOString()} :: mock slice ${input.runId} ====\n`);
+            const child = spawn("node", [scriptPath], {
+                cwd: input.cwd,
+                env: {
+                    ...process.env,
+                    ...input.env,
+                },
+                stdio: ["ignore", "pipe", "pipe"],
+                // Keep the mock worker as a normal child so stdout/stderr capture is deterministic.
+                detached: false,
+            });
+            deps.autoContinueSliceChildren.set(input.runId, child);
+            try {
+                logStream.write(`spawned pid=${String(child.pid ?? "")} stdout=${String(Boolean(child.stdout))} stderr=${String(Boolean(child.stderr))}\n`);
+            }
+            catch {
+                // ignore
+            }
+            child.stdout?.on("data", (chunk) => {
+                try {
+                    logStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.stderr?.on("data", (chunk) => {
+                try {
+                    logStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.on("close", (code, signal) => {
+                deps.autoContinueSliceChildren.delete(input.runId);
+                const stamp = new Date().toISOString();
+                const wroteFallback = writeFallbackSliceOutput({
+                    outputPath: input.outputPath,
+                    runId: input.runId,
+                    workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                    workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                    code,
+                    signal,
+                    reason: "mock worker close",
+                });
+                try {
+                    if (wroteFallback) {
+                        logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                    }
+                    logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    logStream.end();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.end();
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.on("error", (error) => {
+                deps.autoContinueSliceChildren.delete(input.runId);
+                const msg = deps.safeErrorMessage(error);
+                try {
+                    logStream.write(`\nworker error: ${msg}\n`);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.write(`${JSON.stringify({
+                        status: "error",
+                        summary: `Worker spawn error: ${msg}`,
+                        workstream_id: input.env.ORGX_WORKSTREAM_ID ?? "unknown",
+                        workstream_title: input.env.ORGX_WORKSTREAM_TITLE ?? null,
+                        slice_id: input.runId,
+                    }, null, 2)}\n`);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            return { pid: child.pid ?? null };
+        }
+        if (workerKind === "claude-code" || workerKind === "claude_code") {
+            const hasArgFlag = (args, flag) => args.includes(flag) || args.some((arg) => typeof arg === "string" && arg.startsWith(`${flag}=`));
+            const readArgValue = (args, flag) => {
+                const inline = args.find((arg) => typeof arg === "string" && arg.startsWith(`${flag}=`));
+                if (inline)
+                    return inline.slice(flag.length + 1).trim() || null;
+                const index = args.indexOf(flag);
+                const next = index >= 0 ? args[index + 1] : null;
+                return typeof next === "string" && next.trim().length > 0 ? next.trim() : null;
+            };
+            const claudeBin = (process.env.ORGX_CLAUDE_CODE_BIN ?? "").trim() || "claude";
+            const rawArgs = (process.env.ORGX_CLAUDE_CODE_ARGS ?? "").trim();
+            const args = rawArgs.length > 0 ? rawArgs.split(/\s+/).filter(Boolean) : [];
+            const hasPrint = hasArgFlag(args, "--print") || args.includes("-p");
+            const hasOutputFormat = hasArgFlag(args, "--output-format");
+            const hasJsonSchema = hasArgFlag(args, "--json-schema");
+            const hasNoSessionPersistence = hasArgFlag(args, "--no-session-persistence");
+            const hasPermissionMode = hasArgFlag(args, "--permission-mode");
+            const hasDangerousSkipPermissions = hasArgFlag(args, "--dangerously-skip-permissions");
+            const hasAllowDangerousSkipPermissions = hasArgFlag(args, "--allow-dangerously-skip-permissions");
+            const explicitOutputFormat = readArgValue(args, "--output-format");
+            const explicitJsonSchemaArg = readArgValue(args, "--json-schema");
+            const explicitPermissionMode = readArgValue(args, "--permission-mode");
+            let schemaArg = null;
+            if (input.outputSchemaPath && !hasJsonSchema) {
+                try {
+                    const schemaRaw = readFileSync(input.outputSchemaPath, "utf8").trim();
+                    if (schemaRaw.length > 0)
+                        schemaArg = schemaRaw;
+                }
+                catch {
+                    schemaArg = null;
+                }
+            }
+            const claudeExtraArgs = [];
+            if (!hasPrint)
+                claudeExtraArgs.push("--print");
+            if (!hasOutputFormat)
+                claudeExtraArgs.push("--output-format", "json");
+            if (!hasNoSessionPersistence)
+                claudeExtraArgs.push("--no-session-persistence");
+            if (!hasPermissionMode)
+                claudeExtraArgs.push("--permission-mode", "bypassPermissions");
+            if (!hasDangerousSkipPermissions && !hasAllowDangerousSkipPermissions) {
+                claudeExtraArgs.push("--dangerously-skip-permissions");
+            }
+            if (schemaArg)
+                claudeExtraArgs.push("--json-schema", schemaArg);
+            const logStream = createWriteStream(input.logPath, { flags: "a" });
+            const outStream = createWriteStream(input.outputPath, { flags: "a" });
+            logStream.write(`\n==== ${new Date().toISOString()} :: claude slice ${input.runId} ====\n`);
+            logStream.write(`claude_bin: ${claudeBin}\n`);
+            if (claudeExtraArgs.length > 0) {
+                const claudeArgsForLog = claudeExtraArgs.map((arg) => {
+                    if (schemaArg && arg === schemaArg)
+                        return "<json-schema>";
+                    return arg.length > 160 ? `${arg.slice(0, 157)}...` : arg;
+                });
+                logStream.write(`claude_args_injected: ${claudeArgsForLog.join(" ")}\n`);
+            }
+            if (schemaArg && input.outputSchemaPath) {
+                logStream.write(`claude_json_schema: ${input.outputSchemaPath}\n`);
+            }
+            else if (hasJsonSchema) {
+                logStream.write(`claude_json_schema: ${explicitJsonSchemaArg ?? "provided-via-args"}\n`);
+            }
+            else if (input.outputSchemaPath && !hasJsonSchema) {
+                logStream.write(`claude_json_schema: unavailable (${input.outputSchemaPath})\n`);
+            }
+            logStream.write(`claude_output_format: ${hasOutputFormat ? explicitOutputFormat ?? "provided" : "json"}\n`);
+            logStream.write(`claude_permission_mode: ${hasPermissionMode ? explicitPermissionMode ?? "provided" : "bypassPermissions"}\n`);
+            logStream.write(`claude_skip_permissions: ${hasDangerousSkipPermissions || hasAllowDangerousSkipPermissions ? "provided" : "dangerously-skip-permissions"}\n`);
+            const childEnv = {
+                ...process.env,
+                ...deps.resolveByokEnvOverrides(),
+                ...input.env,
+            };
+            if (claudeBin.includes(sep)) {
+                const binDir = dirname(claudeBin);
+                childEnv.PATH = childEnv.PATH ? `${binDir}:${childEnv.PATH}` : binDir;
+            }
+            // Force non-interactive structured output by default for parity with codex output-schema mode.
+            // If callers already pass explicit print/output/schema flags, we preserve their args unchanged.
+            const child = spawn(claudeBin, [...args, ...claudeExtraArgs, input.prompt], {
+                cwd: input.cwd,
+                env: childEnv,
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: true,
+            });
+            deps.autoContinueSliceChildren.set(input.runId, child);
+            child.stdout?.on("data", (chunk) => {
+                try {
+                    logStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.stderr?.on("data", (chunk) => {
+                try {
+                    logStream.write(chunk);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.on("close", (code, signal) => {
+                deps.autoContinueSliceChildren.delete(input.runId);
+                const stamp = new Date().toISOString();
+                const wroteFallback = writeFallbackSliceOutput({
+                    outputPath: input.outputPath,
+                    runId: input.runId,
+                    workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                    workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                    code,
+                    signal,
+                    reason: "claude worker close",
+                });
+                try {
+                    if (wroteFallback) {
+                        logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                    }
+                    logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    logStream.end();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.end();
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.on("error", (error) => {
+                deps.autoContinueSliceChildren.delete(input.runId);
+                const msg = deps.safeErrorMessage(error);
+                try {
+                    logStream.write(`\nworker error: ${msg}\n`);
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    outStream.write(`${JSON.stringify({
+                        status: "error",
+                        summary: `Worker spawn error: ${msg}`,
+                        workstream_id: input.env.ORGX_WORKSTREAM_ID ?? "unknown",
+                        workstream_title: input.env.ORGX_WORKSTREAM_TITLE ?? null,
+                        slice_id: input.runId,
+                    }, null, 2)}\n`);
+                }
+                catch {
+                    // ignore
+                }
+            });
+            child.unref();
+            return { pid: child.pid ?? null };
+        }
+        const codexInfo = deps.resolveCodexBinInfo();
+        const codexBin = codexInfo.bin;
+        const rawArgs = (process.env.ORGX_CODEX_ARGS ?? "").trim();
+        const normalizedArgs = normalizeCodexArgs(rawArgs.length > 0
+            ? rawArgs.split(/\s+/).filter(Boolean)
+            : ["exec", "--ephemeral", "--full-auto", "--skip-git-repo-check"]);
+        const args = hasExplicitCodexSubcommand(normalizedArgs)
+            ? normalizedArgs
+            : ["exec", ...normalizedArgs];
+        const extraArgs = [];
+        const logStream = createWriteStream(input.logPath, { flags: "a" });
+        logStream.write(`\n==== ${new Date().toISOString()} :: slice ${input.runId} ====\n`);
+        logStream.write(`codex_bin: ${codexBin}${codexInfo.versionString ? ` (${codexInfo.versionString})` : ""}\n`);
+        const childEnv = {
+            ...process.env,
+            ...deps.resolveByokEnvOverrides(),
+            ...input.env,
+        };
+        const shouldIsolateCodexHome = envFlag("ORGX_AUTOPILOT_ISOLATE_CODEX_HOME", true);
+        const autopilotCodexHome = prepareAutopilotCodexHome();
+        if (autopilotCodexHome) {
+            childEnv.CODEX_HOME = autopilotCodexHome;
+            logStream.write(shouldIsolateCodexHome
+                ? `codex_home: ${autopilotCodexHome}\n`
+                : `codex_home: ${autopilotCodexHome} (forced-safe override while ORGX_AUTOPILOT_ISOLATE_CODEX_HOME=false)\n`);
+        }
+        else if (shouldIsolateCodexHome) {
+            delete childEnv.CODEX_HOME;
+            logStream.write("codex_home: isolation unavailable (default lookup)\n");
+        }
+        else {
+            logStream.write("codex_home: forced-safe override unavailable (inheriting global CODEX_HOME)\n");
+        }
+        if (codexBin.includes(sep)) {
+            const binDir = dirname(codexBin);
+            childEnv.PATH = childEnv.PATH ? `${binDir}:${childEnv.PATH}` : binDir;
+        }
+        const hasOutputLastMessage = args.includes("--output-last-message") ||
+            args.some((arg) => typeof arg === "string" && arg.startsWith("--output-last-message="));
+        const outputArgs = hasOutputLastMessage
+            ? []
+            : ["--output-last-message", input.outputPath];
+        const hasOutputSchema = args.includes("--output-schema") ||
+            args.some((arg) => typeof arg === "string" && arg.startsWith("--output-schema="));
+        const outputSchemaArgs = input.outputSchemaPath && !hasOutputSchema
+            ? ["--output-schema", input.outputSchemaPath]
+            : [];
+        if (outputSchemaArgs.length > 0) {
+            logStream.write(`output_schema: ${input.outputSchemaPath}\n`);
+        }
+        const child = spawn(codexBin, [...args, ...extraArgs, ...outputArgs, ...outputSchemaArgs, input.prompt], {
+            cwd: input.cwd,
+            env: childEnv,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: true,
+        });
+        deps.autoContinueSliceChildren.set(input.runId, child);
+        child.stdout?.on("data", (chunk) => {
+            try {
+                logStream.write(chunk);
+            }
+            catch {
+                // ignore
+            }
+        });
+        child.stderr?.on("data", (chunk) => {
+            try {
+                logStream.write(chunk);
+            }
+            catch {
+                // ignore
+            }
+        });
+        child.on("close", (code, signal) => {
+            deps.autoContinueSliceChildren.delete(input.runId);
+            const stamp = new Date().toISOString();
+            const wroteFallback = writeFallbackSliceOutput({
+                outputPath: input.outputPath,
+                runId: input.runId,
+                workstreamId: input.env.ORGX_WORKSTREAM_ID,
+                workstreamTitle: input.env.ORGX_WORKSTREAM_TITLE,
+                code,
+                signal,
+                reason: "codex worker close",
+            });
+            try {
+                if (wroteFallback) {
+                    logStream.write(`fallback output synthesized at ${input.outputPath}\n`);
+                }
+                logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
+            }
+            catch {
+                // ignore
+            }
+            try {
+                logStream.end();
+            }
+            catch {
+                // ignore
+            }
+        });
+        child.on("error", (error) => {
+            deps.autoContinueSliceChildren.delete(input.runId);
+            const msg = deps.safeErrorMessage(error);
+            try {
+                logStream.write(`\nworker error: ${msg}\n`);
+            }
+            catch {
+                // ignore
+            }
+            try {
+                writeFileSync(input.outputPath, `${JSON.stringify({
+                    status: "error",
+                    summary: `Worker spawn error: ${msg}`,
+                    workstream_id: input.env.ORGX_WORKSTREAM_ID ?? "unknown",
+                    workstream_title: input.env.ORGX_WORKSTREAM_TITLE ?? null,
+                    slice_id: input.runId,
+                }, null, 2)}\n`, { encoding: "utf8" });
+            }
+            catch {
+                // ignore
+            }
+        });
+        child.unref();
+        return { pid: child.pid ?? null };
+    }
+    function writeRuntimeEvent(input) {
+        const instance = deps.upsertRuntimeInstanceFromHook({
+            source_client: input.sourceClient,
+            event: input.event ?? null,
+            run_id: input.runId,
+            correlation_id: input.runId,
+            initiative_id: input.initiativeId,
+            workstream_id: input.workstreamId,
+            task_id: input.taskId,
+            agent_id: input.agentId,
+            agent_name: input.agentName,
+            phase: input.phase,
+            progress_pct: input.progressPct ?? null,
+            message: input.message ?? null,
+            metadata: input.metadata ?? null,
+            timestamp: input.timestamp ?? new Date().toISOString(),
+        });
+        // Make runtime updates feel instantaneous (don't wait for the 15s staleness timer).
+        deps.broadcastRuntimeSse("runtime.updated", instance);
+        deps.clearSnapshotResponseCache();
+        return instance;
+    }
+    return {
+        spawnCodexSliceWorker,
+        writeRuntimeEvent,
+    };
+}

package/dist/http/helpers/autopilot-slice-utils.d.ts

@@ -0,0 +1,56 @@
+export declare function ensureAutopilotSliceSchemaPath(schemaFilename: string): string;
+export declare function parseSliceResult<T extends object>(raw: string): T | null;
+export declare function readSliceOutputFile(pathname: string): string | null;
+export declare function readFileTailSafe(pathname: string, maxChars?: number): string;
+export declare function fileUpdatedAtEpochMs(pathname: string, fallbackEpochMs: number): number;
+export type CodexBinInfo = {
+    bin: string;
+    version: [number, number, number] | null;
+    versionString: string | null;
+};
+export declare function normalizeCodexArgs(args: string[]): string[];
+export declare function createCodexBinResolver(): {
+    resolveCodexBinInfo: () => CodexBinInfo;
+    getCachedCodexProbeSummary: () => string | null;
+};
+export declare function buildSliceOutputInstructions(input: {
+    runId: string;
+    schemaPath: string;
+    requiredSkills: string[];
+}): string;
+export declare function buildWorkstreamSlicePrompt(input: {
+    initiativeTitle: string;
+    initiativeId: string;
+    workstreamId: string;
+    workstreamTitle: string;
+    milestoneSummaries: Array<{
+        id: string;
+        title: string;
+        status: string;
+    }>;
+    taskSummaries: Array<{
+        id: string;
+        title: string;
+        status: string;
+        milestoneId: string | null;
+    }>;
+    executionPolicy: {
+        domain: string;
+        requiredSkills: string[];
+    };
+    behaviorConfig?: {
+        configId?: string | null;
+        version?: string | null;
+        hash?: string | null;
+        policySource?: string | null;
+        context?: string | null;
+    } | null;
+    runId: string;
+    schemaPath: string;
+}): string;
+export type BuildScopeDirectiveScope = "task" | "milestone" | "workstream";
+export declare function buildScopeDirective(scope: BuildScopeDirectiveScope, meta: {
+    milestoneTitles?: string[];
+    workstreamTitle?: string;
+    taskCount: number;
+}): string;