agentplane 0.3.6 → 0.3.8

package/dist/runner/context/base-prompts.js

@@ -0,0 +1,255 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { loadAgentTemplates, loadPolicyGatewayTemplate } from "../../agents/agents-template.js";
+import { fileExists } from "../../cli/fs-utils.js";
+import { resolvePolicyGatewayForRepo, } from "../../shared/policy-gateway.js";
+const FRAMEWORK_RUNNER_PROMPT_URL = new URL("../../../assets/RUNNER.md", import.meta.url);
+const BASE_PROMPT_PRIORITIES = {
+    framework_runner: 100,
+    policy_gateway: 200,
+    owner_profile: 300,
+    recipe_execution_context: 400,
+    recipe_agent_profile: 500,
+    recipe_skill_context: 600,
+    recipe_tools_context: 700,
+};
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function normalizeOwnerId(ownerIdRaw) {
+    const trimmed = ownerIdRaw.trim();
+    if (!trimmed)
+        throw new Error("Runner base prompt collection requires a non-empty owner id.");
+    return trimmed.toUpperCase();
+}
+function normalizeText(text) {
+    return ensureTrailingNewline(text.trimEnd());
+}
+function validateJsonPrompt(source, text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Invalid prompt JSON: ${source} (malformed JSON)`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid prompt JSON: ${source} (expected object)`);
+    }
+    return normalizeText(text);
+}
+function renderRecipePromptJson(value) {
+    return normalizeText(JSON.stringify(value, null, 2));
+}
+function toPromptSource(gitRoot, absPath) {
+    return path.relative(gitRoot, absPath).replaceAll("\\", "/");
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+async function resolveRepoAgentProfilePath(opts) {
+    const agentsDir = path.join(opts.git_root, opts.agents_dir);
+    if (!(await fileExists(agentsDir)))
+        return null;
+    const entries = await readdir(agentsDir);
+    const wanted = `${opts.owner_id}.json`.toLowerCase();
+    const match = entries.find((entry) => entry.endsWith(".json") && entry.toLowerCase() === wanted);
+    if (!match)
+        return null;
+    return path.join(agentsDir, match);
+}
+async function loadOwnerProfilePrompt(opts) {
+    const repoProfilePath = await resolveRepoAgentProfilePath(opts);
+    if (repoProfilePath) {
+        const source = toPromptSource(opts.git_root, repoProfilePath);
+        const content = validateJsonPrompt(source, await readFile(repoProfilePath, "utf8"));
+        return {
+            id: "base.owner_profile",
+            role: "profile",
+            title: `Owner Agent Profile (${opts.owner_id})`,
+            source,
+            priority: BASE_PROMPT_PRIORITIES.owner_profile,
+            content,
+        };
+    }
+    const bundledFileName = `${opts.owner_id}.json`;
+    const bundledTemplates = await loadAgentTemplates();
+    const bundled = bundledTemplates.find((entry) => entry.fileName.toLowerCase() === bundledFileName.toLowerCase());
+    if (!bundled) {
+        throw new Error(`Bundled agent profile not found: ${bundledFileName}`);
+    }
+    return {
+        id: "base.owner_profile",
+        role: "profile",
+        title: `Owner Agent Profile (${opts.owner_id})`,
+        source: `bundled:agent-profile:${bundled.fileName}`,
+        priority: BASE_PROMPT_PRIORITIES.owner_profile,
+        content: validateJsonPrompt(`bundled:agent-profile:${bundled.fileName}`, bundled.contents),
+    };
+}
+async function loadFrameworkRunnerPrompt() {
+    return {
+        id: "base.framework_runner",
+        role: "system",
+        title: "Framework Runner Prompt",
+        source: "bundled:runner-prompt:RUNNER.md",
+        priority: BASE_PROMPT_PRIORITIES.framework_runner,
+        content: normalizeText(await readFile(FRAMEWORK_RUNNER_PROMPT_URL, "utf8")),
+    };
+}
+async function loadPolicyGatewayPrompt(opts) {
+    const gateway = await resolvePolicyGatewayForRepo({
+        gitRoot: opts.git_root,
+        fallbackFlavor: opts.fallback_flavor,
+    });
+    if (await fileExists(gateway.absPath)) {
+        const source = path.relative(opts.git_root, gateway.absPath).replaceAll("\\", "/");
+        return {
+            id: "base.policy_gateway",
+            role: "policy",
+            title: `Repository Policy Gateway (${gateway.fileName})`,
+            source,
+            priority: BASE_PROMPT_PRIORITIES.policy_gateway,
+            content: normalizeText(await readFile(gateway.absPath, "utf8")),
+        };
+    }
+    return {
+        id: "base.policy_gateway",
+        role: "policy",
+        title: `Bundled Policy Gateway Fallback (${gateway.fileName})`,
+        source: `bundled:policy-gateway:${gateway.fileName}`,
+        priority: BASE_PROMPT_PRIORITIES.policy_gateway,
+        content: await loadPolicyGatewayTemplate(gateway.flavor),
+    };
+}
+async function loadRecipePromptJsonBlock(opts) {
+    const relativeFile = opts.relative_file?.trim();
+    if (relativeFile) {
+        const absPath = path.join(opts.recipe_dir, relativeFile);
+        if (await fileExists(absPath)) {
+            const source = toPromptSource(opts.git_root, absPath);
+            return {
+                id: opts.prompt_id,
+                role: opts.role,
+                title: opts.title,
+                source,
+                priority: opts.priority,
+                content: validateJsonPrompt(source, await readFile(absPath, "utf8")),
+            };
+        }
+    }
+    return {
+        id: opts.prompt_id,
+        role: opts.role,
+        title: opts.title,
+        source: opts.fallback_source,
+        priority: opts.priority,
+        content: renderRecipePromptJson(opts.fallback_payload),
+    };
+}
+async function collectRecipePromptBlocks(opts) {
+    const recipeDir = opts.recipe.recipe_dir?.trim();
+    if (!recipeDir)
+        return [];
+    const promptBlocks = [];
+    const scenario = isRecord(opts.recipe.scenario) ? opts.recipe.scenario : {};
+    const executionContext = {
+        recipe: {
+            id: opts.recipe.recipe_id,
+            name: opts.recipe.recipe_name ?? null,
+            version: opts.recipe.recipe_version ?? null,
+            scenario_id: opts.recipe.scenario_id,
+            scenario_file: opts.recipe.scenario_file ?? null,
+        },
+        selection_reasons: opts.recipe.selection_reasons ?? [],
+        run_profile: opts.recipe.run_profile ?? {},
+        scenario: {
+            summary: typeof scenario.summary === "string" ? scenario.summary : null,
+            description: typeof scenario.description === "string" ? scenario.description : null,
+            goal: typeof scenario.goal === "string" ? scenario.goal : null,
+            evidence: isRecord(scenario.evidence) ? scenario.evidence : null,
+            outputs: readOptionalStringArray(scenario.outputs),
+        },
+    };
+    promptBlocks.push({
+        id: "recipe.execution_context",
+        role: "context",
+        title: `Recipe Scenario Context (${opts.recipe.recipe_id}:${opts.recipe.scenario_id})`,
+        source: `recipe:${opts.recipe.recipe_id}:${opts.recipe.scenario_id}`,
+        priority: BASE_PROMPT_PRIORITIES.recipe_execution_context,
+        content: renderRecipePromptJson(executionContext),
+    });
+    const agentBlocks = await Promise.all((opts.recipe.agents ?? []).map(async (agent, index) => {
+        const agentId = typeof agent.id === "string" ? agent.id : `agent_${index + 1}`;
+        return loadRecipePromptJsonBlock({
+            git_root: opts.git_root,
+            recipe_dir: recipeDir,
+            prompt_id: `recipe.agent.${agentId}`,
+            role: "profile",
+            title: `Recipe Agent Prompt (${agentId})`,
+            relative_file: typeof agent.file === "string" ? agent.file : undefined,
+            fallback_source: `recipe:${opts.recipe.recipe_id}:agent:${agentId}`,
+            fallback_payload: agent,
+            priority: BASE_PROMPT_PRIORITIES.recipe_agent_profile + index,
+        });
+    }));
+    promptBlocks.push(...agentBlocks);
+    const skillBlocks = await Promise.all((opts.recipe.skills ?? []).map(async (skill, index) => {
+        const skillId = typeof skill.id === "string" ? skill.id : `skill_${index + 1}`;
+        return loadRecipePromptJsonBlock({
+            git_root: opts.git_root,
+            recipe_dir: recipeDir,
+            prompt_id: `recipe.skill.${skillId}`,
+            role: "context",
+            title: `Recipe Skill Prompt (${skillId})`,
+            relative_file: typeof skill.file === "string" ? skill.file : undefined,
+            fallback_source: `recipe:${opts.recipe.recipe_id}:skill:${skillId}`,
+            fallback_payload: skill,
+            priority: BASE_PROMPT_PRIORITIES.recipe_skill_context + index,
+        });
+    }));
+    promptBlocks.push(...skillBlocks);
+    if ((opts.recipe.tools ?? []).length > 0) {
+        const toolPayload = (opts.recipe.tools ?? []).map((tool) => ({
+            id: typeof tool.id === "string" ? tool.id : null,
+            summary: typeof tool.summary === "string" ? tool.summary : null,
+            runtime: typeof tool.runtime === "string" ? tool.runtime : null,
+            entrypoint: typeof tool.entrypoint === "string" ? tool.entrypoint : null,
+            permissions: readOptionalStringArray(tool.permissions),
+            timeout_ms: typeof tool.timeout_ms === "number" ? tool.timeout_ms : null,
+            cwd_policy: typeof tool.cwd_policy === "string" ? tool.cwd_policy : null,
+        }));
+        promptBlocks.push({
+            id: "recipe.tools_summary",
+            role: "context",
+            title: "Recipe Tool Context",
+            source: `recipe:${opts.recipe.recipe_id}:tools`,
+            priority: BASE_PROMPT_PRIORITIES.recipe_tools_context,
+            content: renderRecipePromptJson(toolPayload),
+        });
+    }
+    return promptBlocks;
+}
+export async function collectRunnerBasePrompts(opts) {
+    const owner_id = normalizeOwnerId(opts.owner_id);
+    const trimmedAgentsDir = opts.agents_dir?.trim();
+    const agents_dir = trimmedAgentsDir && trimmedAgentsDir.length > 0 ? trimmedAgentsDir : ".agentplane/agents";
+    const fallback_flavor = opts.fallback_policy_gateway_flavor ?? "codex";
+    const prompts = [
+        ...(await Promise.all([
+            loadFrameworkRunnerPrompt(),
+            loadPolicyGatewayPrompt({ git_root: opts.git_root, fallback_flavor }),
+            loadOwnerProfilePrompt({ git_root: opts.git_root, agents_dir, owner_id }),
+        ])),
+        ...(await collectRecipePromptBlocks({
+            git_root: opts.git_root,
+            recipe: opts.recipe ?? { recipe_id: "", scenario_id: "" },
+        })),
+    ];
+    return prompts.toSorted((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
+}

package/dist/runner/context/recipe-context.d.ts

@@ -0,0 +1,17 @@
+import type { ResolvedProject } from "@agentplaneorg/core";
+import { readProjectInstalledRecipes, type ResolvedRecipeScenarioSelection, type ScenarioDefinition } from "../../commands/recipes.js";
+import type { RunnerRecipeContext } from "../types.js";
+type InstalledRecipeEntry = Awaited<ReturnType<typeof readProjectInstalledRecipes>>["recipes"][number];
+export type RunnerRecipeContextEnvelope = {
+    entry: InstalledRecipeEntry;
+    selection: ResolvedRecipeScenarioSelection;
+    scenario: ScenarioDefinition;
+    recipe: RunnerRecipeContext;
+};
+export declare function assembleRunnerRecipeContext(opts: {
+    project: ResolvedProject;
+    recipe_id: string;
+    scenario_id: string;
+}): Promise<RunnerRecipeContextEnvelope>;
+export {};
+//# sourceMappingURL=recipe-context.d.ts.map

package/dist/runner/context/recipe-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipe-context.d.ts","sourceRoot":"","sources":["../../../src/runner/context/recipe-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EACL,2BAA2B,EAG3B,KAAK,+BAA+B,EACpC,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,KAAK,oBAAoB,GAAG,OAAO,CACjC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAC/C,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAErB,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,EAAE,oBAAoB,CAAC;IAC5B,SAAS,EAAE,+BAA+B,CAAC;IAC3C,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AAkCF,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA2BvC"}

package/dist/runner/context/recipe-context.js

@@ -0,0 +1,48 @@
+import { readProjectInstalledRecipes, readScenarioDefinition, resolveRecipeScenarioSelection, } from "../../commands/recipes.js";
+import { CliError } from "../../shared/errors.js";
+function toRecipeContext(opts) {
+    const agents = (opts.entry.manifest.agents ?? []).filter((agent) => opts.selection.agents_involved.includes(agent.id));
+    const skills = (opts.entry.manifest.skills ?? []).filter((skill) => opts.selection.skills_used.includes(skill.id));
+    const tools = (opts.entry.manifest.tools ?? []).filter((tool) => opts.selection.tools_used.includes(tool.id));
+    return {
+        recipe_id: opts.entry.id,
+        scenario_id: opts.selection.scenario_id,
+        recipe_name: opts.entry.manifest.name,
+        recipe_version: opts.entry.version,
+        recipe_dir: opts.selection.recipe_dir,
+        scenario_file: opts.selection.scenario_file,
+        run_profile: opts.selection.run_profile,
+        selection_reasons: [...opts.selection.selection_reasons],
+        manifest: opts.entry.manifest,
+        scenario: opts.scenario,
+        agents: agents,
+        skills: skills,
+        tools: tools,
+    };
+}
+export async function assembleRunnerRecipeContext(opts) {
+    const installed = await readProjectInstalledRecipes(opts.project);
+    const entry = installed.recipes.find((candidate) => candidate.id === opts.recipe_id);
+    if (!entry) {
+        throw new CliError({
+            exitCode: 4,
+            code: "E_IO",
+            message: `Recipe not installed: ${opts.recipe_id}`,
+        });
+    }
+    const selection = await resolveRecipeScenarioSelection({
+        project: opts.project,
+        flags: {
+            recipeId: opts.recipe_id,
+            scenarioId: opts.scenario_id,
+            includeIncompatible: true,
+        },
+    });
+    const scenario = await readScenarioDefinition(selection.scenario_file);
+    return {
+        entry,
+        selection,
+        scenario,
+        recipe: toRecipeContext({ entry, selection, scenario }),
+    };
+}

package/dist/runner/context/task-context.d.ts

@@ -0,0 +1,24 @@
+import type { CommandContext } from "../../commands/shared/task-backend.js";
+import type { RunnerRepositoryContext, RunnerTaskContext } from "../types.js";
+export type RunnerTaskContextEnvelope = {
+    repository: RunnerRepositoryContext;
+    task: RunnerTaskContext;
+};
+export declare const RUNNER_TASK_CONTEXT_BUDGETS: {
+    readonly doc_max_bytes: 24576;
+    readonly section_max_bytes: 3072;
+    readonly sections_total_max_bytes: 20480;
+    readonly comments_max_count: 20;
+    readonly comment_body_max_bytes: 1024;
+    readonly comments_total_max_bytes: 12288;
+    readonly events_max_count: 40;
+    readonly event_note_max_bytes: 768;
+    readonly events_total_max_bytes: 16384;
+};
+export declare function assembleRunnerTaskContext(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+}): Promise<RunnerTaskContextEnvelope>;
+//# sourceMappingURL=task-context.d.ts.map

package/dist/runner/context/task-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-context.d.ts","sourceRoot":"","sources":["../../../src/runner/context/task-context.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAEV,uBAAuB,EACvB,iBAAiB,EAGlB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,EAAE,uBAAuB,CAAC;IACpC,IAAI,EAAE,iBAAiB,CAAC;CACzB,CAAC;AAKF,eAAO,MAAM,2BAA2B;;;;;;;;;;CAU9B,CAAC;AA2OX,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA0DrC"}

package/dist/runner/context/task-context.js

@@ -0,0 +1,266 @@
+import path from "node:path";
+import { renderTaskDocFromSections, taskDocToSectionMap } from "@agentplaneorg/core";
+import { mapBackendError } from "../../cli/error-map.js";
+import { fileExists } from "../../cli/fs-utils.js";
+import { loadCommandContext, loadTaskFromContext, taskDataToFrontmatter, } from "../../commands/shared/task-backend.js";
+import { gitCurrentBranch } from "../../commands/shared/git-ops.js";
+import { resolveTaskDependencyState } from "../../commands/task/shared.js";
+import { CliError } from "../../shared/errors.js";
+const TRUNCATED_MARKER = "\n\n[TRUNCATED]";
+const OMITTED_SECTION_MARKER = "[TRUNCATED: omitted due to task context budget]";
+export const RUNNER_TASK_CONTEXT_BUDGETS = {
+    doc_max_bytes: 24_576,
+    section_max_bytes: 3072,
+    sections_total_max_bytes: 20_480,
+    comments_max_count: 20,
+    comment_body_max_bytes: 1024,
+    comments_total_max_bytes: 12_288,
+    events_max_count: 40,
+    event_note_max_bytes: 768,
+    events_total_max_bytes: 16_384,
+};
+function toRunnerDependencyState(dep) {
+    const missing = [...dep.missing];
+    const incomplete = [...dep.incomplete];
+    const completed = dep.dependsOn.filter((taskId) => !missing.includes(taskId) && !incomplete.includes(taskId));
+    return {
+        ready: missing.length === 0 && incomplete.length === 0,
+        missing,
+        incomplete,
+        completed,
+    };
+}
+function utf8Bytes(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+function truncateUtf8(text, maxBytes, marker = TRUNCATED_MARKER) {
+    if (maxBytes <= 0)
+        return "";
+    if (utf8Bytes(text) <= maxBytes)
+        return text;
+    const markerBytes = utf8Bytes(marker);
+    if (markerBytes >= maxBytes) {
+        let head = "";
+        for (const char of marker) {
+            const next = head + char;
+            if (utf8Bytes(next) > maxBytes)
+                break;
+            head = next;
+        }
+        return head;
+    }
+    let head = "";
+    for (const char of text) {
+        const candidate = head + char;
+        if (utf8Bytes(candidate) + markerBytes > maxBytes)
+            break;
+        head = candidate;
+    }
+    return `${head}${marker}`;
+}
+function compactByTotalBudget(opts) {
+    const selected = opts.items.slice(-opts.maxCount);
+    while (selected.length > 1 &&
+        selected.reduce((sum, item) => sum + opts.measure(item), 0) > opts.maxTotalBytes) {
+        selected.shift();
+    }
+    return selected;
+}
+function measureComments(comments) {
+    return utf8Bytes(JSON.stringify(comments));
+}
+function measureEvents(events) {
+    return utf8Bytes(JSON.stringify(events));
+}
+function prioritizeSections(sections) {
+    const preferredOrder = [
+        "Summary",
+        "Scope",
+        "Plan",
+        "Verify Steps",
+        "Verification",
+        "Rollback Plan",
+        "Findings",
+    ];
+    const entries = Object.entries(sections);
+    const indexByKey = new Map(entries.map(([key], index) => [key, index]));
+    return entries.toSorted(([left], [right]) => {
+        const leftPreferred = preferredOrder.indexOf(left);
+        const rightPreferred = preferredOrder.indexOf(right);
+        if (leftPreferred !== -1 && rightPreferred !== -1)
+            return leftPreferred - rightPreferred;
+        if (leftPreferred !== -1)
+            return -1;
+        if (rightPreferred !== -1)
+            return 1;
+        return (indexByKey.get(left) ?? 0) - (indexByKey.get(right) ?? 0);
+    });
+}
+function compactSections(sections) {
+    const originalEntries = prioritizeSections(sections);
+    const originalDoc = renderTaskDocFromSections(sections);
+    let remainingBudget = RUNNER_TASK_CONTEXT_BUDGETS.sections_total_max_bytes;
+    let truncated = false;
+    const compactedEntries = originalEntries.map(([section, text]) => {
+        if (!text)
+            return [section, text];
+        if (remainingBudget <= 0) {
+            truncated = true;
+            return [section, OMITTED_SECTION_MARKER];
+        }
+        const allowedBytes = Math.min(RUNNER_TASK_CONTEXT_BUDGETS.section_max_bytes, remainingBudget);
+        const nextText = utf8Bytes(text) > allowedBytes ? truncateUtf8(text, allowedBytes) : text;
+        if (nextText !== text)
+            truncated = true;
+        remainingBudget = Math.max(0, remainingBudget - utf8Bytes(nextText));
+        return [section, nextText];
+    });
+    const compactedSections = Object.fromEntries(compactedEntries);
+    const compactedDoc = truncateUtf8(renderTaskDocFromSections(compactedSections), RUNNER_TASK_CONTEXT_BUDGETS.doc_max_bytes);
+    const docTruncated = compactedDoc !== originalDoc;
+    return {
+        sections: compactedSections,
+        doc: compactedDoc,
+        compaction: {
+            original_bytes: utf8Bytes(JSON.stringify(sections)),
+            emitted_bytes: utf8Bytes(JSON.stringify(compactedSections)),
+            original_count: originalEntries.length,
+            emitted_count: compactedEntries.length,
+            truncated,
+        },
+        docCompaction: {
+            original_bytes: utf8Bytes(originalDoc),
+            emitted_bytes: utf8Bytes(compactedDoc),
+            truncated: docTruncated,
+        },
+    };
+}
+function compactComments(comments) {
+    const originalBytes = measureComments(comments);
+    const truncatedBodies = comments.map((comment) => ({
+        author: comment.author,
+        body: truncateUtf8(comment.body, RUNNER_TASK_CONTEXT_BUDGETS.comment_body_max_bytes),
+    }));
+    const compacted = compactByTotalBudget({
+        items: truncatedBodies,
+        maxCount: RUNNER_TASK_CONTEXT_BUDGETS.comments_max_count,
+        maxTotalBytes: RUNNER_TASK_CONTEXT_BUDGETS.comments_total_max_bytes,
+        measure: (item) => measureComments([item]),
+    });
+    return {
+        comments: compacted,
+        compaction: {
+            original_bytes: originalBytes,
+            emitted_bytes: measureComments(compacted),
+            original_count: comments.length,
+            emitted_count: compacted.length,
+            truncated: compacted.length !== comments.length ||
+                compacted.some((comment, index) => comment.body !== truncatedBodies.at(-(compacted.length - index))?.body),
+        },
+    };
+}
+function compactEvents(events) {
+    const originalBytes = measureEvents(events);
+    const truncatedNotes = events.map((event) => event.note
+        ? {
+            ...event,
+            note: truncateUtf8(event.note, RUNNER_TASK_CONTEXT_BUDGETS.event_note_max_bytes),
+        }
+        : event);
+    const compacted = compactByTotalBudget({
+        items: truncatedNotes,
+        maxCount: RUNNER_TASK_CONTEXT_BUDGETS.events_max_count,
+        maxTotalBytes: RUNNER_TASK_CONTEXT_BUDGETS.events_total_max_bytes,
+        measure: (item) => measureEvents([item]),
+    });
+    return {
+        events: compacted,
+        compaction: {
+            original_bytes: originalBytes,
+            emitted_bytes: measureEvents(compacted),
+            original_count: events.length,
+            emitted_count: compacted.length,
+            truncated: compacted.length !== events.length ||
+                compacted.some((event, index) => {
+                    const original = truncatedNotes.at(-(compacted.length - index));
+                    return JSON.stringify(event) !== JSON.stringify(original);
+                }),
+        },
+    };
+}
+async function resolveTaskReadmePath(ctx, taskId) {
+    const readmePath = path.join(ctx.resolvedProject.gitRoot, ctx.config.paths.workflow_dir, taskId, "README.md");
+    return (await fileExists(readmePath)) ? readmePath : undefined;
+}
+async function readOptionalBranch(gitRoot) {
+    try {
+        return await gitCurrentBranch(gitRoot);
+    }
+    catch {
+        return null;
+    }
+}
+async function readOptionalHeadCommit(ctx) {
+    try {
+        return await ctx.git.headCommit();
+    }
+    catch {
+        return null;
+    }
+}
+export async function assembleRunnerTaskContext(opts) {
+    try {
+        const ctx = opts.ctx ??
+            (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+        const task = await loadTaskFromContext({ ctx, taskId: opts.task_id });
+        const dependencyState = toRunnerDependencyState(await resolveTaskDependencyState(task, ctx.taskBackend));
+        const frontmatter = taskDataToFrontmatter(task);
+        const baseDoc = typeof task.doc === "string"
+            ? task.doc
+            : task.sections
+                ? renderTaskDocFromSections(task.sections)
+                : "";
+        const baseSections = task.sections ?? (baseDoc ? taskDocToSectionMap(baseDoc) : {});
+        const compactedSections = compactSections(baseSections);
+        const compactedComments = compactComments(task.comments ?? []);
+        const compactedEvents = compactEvents(task.events ?? []);
+        const compaction = {
+            doc: compactedSections.docCompaction,
+            sections: compactedSections.compaction,
+            comments: compactedComments.compaction,
+            events: compactedEvents.compaction,
+        };
+        const [branch, head_commit, readme_path] = await Promise.all([
+            readOptionalBranch(ctx.resolvedProject.gitRoot),
+            readOptionalHeadCommit(ctx),
+            resolveTaskReadmePath(ctx, task.id),
+        ]);
+        return {
+            repository: {
+                git_root: ctx.resolvedProject.gitRoot,
+                workflow_dir: ctx.config.paths.workflow_dir,
+                backend_id: ctx.backendId,
+                backend_config_path: ctx.backendConfigPath,
+                branch,
+                head_commit,
+            },
+            task: {
+                task_id: task.id,
+                data: task,
+                frontmatter,
+                doc: compactedSections.doc,
+                sections: compactedSections.sections,
+                comments: compactedComments.comments,
+                events: compactedEvents.events,
+                readme_path,
+                dependency_state: dependencyState,
+                compaction,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, { task_id: opts.task_id });
+    }
+}

package/dist/runner/index.d.ts

@@ -0,0 +1,12 @@
+export { appendRunnerEvent, createRunnerRunState, evolveRunnerRunState, readRunnerRunState, writeRunnerRunState, writePreparedRunnerArtifacts, } from "./artifacts.js";
+export { createRunnerRunId } from "./run-id.js";
+export { RUNNER_BOOTSTRAP_FILENAME, RUNNER_BUNDLE_FILENAME, RUNNER_EVENTS_FILENAME, RUNNER_STATE_FILENAME, resolveTaskRunnerPaths, type TaskRunnerPaths, } from "./task-run-paths.js";
+export { RUNNER_API_VERSION, RUNNER_BUNDLE_SCHEMA_VERSION, type RunnerArtifactPaths, type RunnerContextBundle, type RunnerDependencyState, type RunnerEvent, type RunnerExecutionContract, type RunnerInvocation, type RunnerLifecycleStatus, type RunnerPromptBlock, type RunnerPromptRole, type RunnerRecipeContext, type RunnerRepositoryContext, type RunnerResult, type RunnerResultStatus, type RunnerRunState, type RunnerTarget, type RunnerTaskContext, } from "./types.js";
+export { collectRunnerBasePrompts } from "./context/base-prompts.js";
+export { assembleRunnerRecipeContext, type RunnerRecipeContextEnvelope, } from "./context/recipe-context.js";
+export { assembleRunnerTaskContext, type RunnerTaskContextEnvelope, } from "./context/task-context.js";
+export { KNOWN_RUNNER_ADAPTER_IDS, resolveRunnerAdapterId } from "./config.js";
+export { CodexRunnerAdapter, createRunnerAdapter, runnerAdapterFailureResult, runnerAdapterSuccessResult, type RunnerAdapter, } from "./adapters/index.js";
+export { executeTaskRunnerExecution, prepareTaskRunnerExecution, type ExecutedTaskRunnerExecution, type PreparedTaskRunnerExecution, } from "./usecases/task-run.js";
+export { buildMaterializedRecipeTask, materializeRecipeScenarioTask, type MaterializedRecipeScenarioTask, } from "./usecases/scenario-materialize-task.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runner/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EACL,2BAA2B,EAC3B,KAAK,2BAA2B,GACjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,yBAAyB,EACzB,KAAK,yBAAyB,GAC/B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,0BAA0B,EAC1B,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,GACjC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,KAAK,8BAA8B,GACpC,MAAM,yCAAyC,CAAC"}

package/dist/runner/index.js

@@ -0,0 +1,11 @@
+export { appendRunnerEvent, createRunnerRunState, evolveRunnerRunState, readRunnerRunState, writeRunnerRunState, writePreparedRunnerArtifacts, } from "./artifacts.js";
+export { createRunnerRunId } from "./run-id.js";
+export { RUNNER_BOOTSTRAP_FILENAME, RUNNER_BUNDLE_FILENAME, RUNNER_EVENTS_FILENAME, RUNNER_STATE_FILENAME, resolveTaskRunnerPaths, } from "./task-run-paths.js";
+export { RUNNER_API_VERSION, RUNNER_BUNDLE_SCHEMA_VERSION, } from "./types.js";
+export { collectRunnerBasePrompts } from "./context/base-prompts.js";
+export { assembleRunnerRecipeContext, } from "./context/recipe-context.js";
+export { assembleRunnerTaskContext, } from "./context/task-context.js";
+export { KNOWN_RUNNER_ADAPTER_IDS, resolveRunnerAdapterId } from "./config.js";
+export { CodexRunnerAdapter, createRunnerAdapter, runnerAdapterFailureResult, runnerAdapterSuccessResult, } from "./adapters/index.js";
+export { executeTaskRunnerExecution, prepareTaskRunnerExecution, } from "./usecases/task-run.js";
+export { buildMaterializedRecipeTask, materializeRecipeScenarioTask, } from "./usecases/scenario-materialize-task.js";

package/dist/runner/policy-decision.d.ts

@@ -0,0 +1,12 @@
+import type { CliError } from "../shared/errors.js";
+import type { RunnerAdapterCapabilities, RunnerPolicyDecision, RunnerRecipeContext } from "./types.js";
+export declare function buildRunnerPolicyDecision(opts: {
+    adapter_id: string;
+    capabilities: RunnerAdapterCapabilities | undefined;
+    recipe: RunnerRecipeContext | undefined;
+}): RunnerPolicyDecision;
+export declare function applyRunnerPolicyRefusal(opts: {
+    decision: RunnerPolicyDecision;
+    error: CliError;
+}): RunnerPolicyDecision;
+//# sourceMappingURL=policy-decision.d.ts.map

package/dist/runner/policy-decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-decision.d.ts","sourceRoot":"","sources":["../../src/runner/policy-decision.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EACV,yBAAyB,EACzB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAcpB,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,yBAAyB,GAAG,SAAS,CAAC;IACpD,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACzC,GAAG,oBAAoB,CAiEvB;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,KAAK,EAAE,QAAQ,CAAC;CACjB,GAAG,oBAAoB,CAcvB"}