agentera 3.0.0-dev.4 → 3.0.0-dev.46

package/dist/cli/capabilityContext/projectVerification.js

@@ -0,0 +1,409 @@
+import path from "node:path";
+import { assertValidatedProjectRoot, validateRealProjectRoot, } from "../../state/projectRoot.js";
+import { projectPathIsStable, readProjectFileSnapshot, snapshotProjectPath, } from "../../state/safeProjectFile.js";
+const MAX_SOURCE_BYTES = 64 * 1024;
+const MAX_RECIPE_ROWS = 40;
+const MAX_COMMANDS = 12;
+const MAX_EVALUATED_COMMANDS = 64;
+const MAX_PROVENANCE = 16;
+const MAX_REJECTIONS = 12;
+const MAX_DIAGNOSTICS = 8;
+const MAX_ALIAS_DEPTH = 8;
+const MAX_POINTER_STRING = 160;
+const VERIFICATION_LABEL = /\b(validate|verification|tests?|package boundary|typecheck|build|compaction|lint)\b/i;
+const SAFE_TOKEN = /^[A-Za-z0-9@._:/=-]+$/;
+const SCRIPT_NAME = /^[A-Za-z0-9@._:-]+$/;
+export function discoverProjectVerification(projectRoot) {
+    const resolvedRoot = path.resolve(projectRoot);
+    let validatedRoot = null;
+    try {
+        validatedRoot = validateRealProjectRoot(resolvedRoot);
+    }
+    catch {
+        validatedRoot = null;
+    }
+    const state = {
+        projectRoot: resolvedRoot,
+        validatedRoot,
+        rejections: [],
+        diagnostics: [],
+        rejectionOmitted: 0,
+        diagnosticOmitted: 0,
+        candidateCommandOmitted: 0,
+    };
+    if (state.validatedRoot === null)
+        diagnostic(state, "Project root is missing, symlinked, or unsafe.");
+    const candidates = readRecipeCandidates(state);
+    const resolvedRows = [];
+    let processedCommands = 0;
+    for (const candidate of candidates) {
+        const commands = [];
+        for (const command of candidate.commands) {
+            if (processedCommands >= MAX_EVALUATED_COMMANDS) {
+                state.candidateCommandOmitted += 1;
+                continue;
+            }
+            processedCommands += 1;
+            const resolved = resolveCommand(state, candidate, command);
+            if (resolved)
+                commands.push(resolved);
+        }
+        resolvedRows.push({ candidate, commands });
+    }
+    if (state.candidateCommandOmitted > 0)
+        diagnostic(state, "Verification command evaluation limit reached.");
+    const accepted = new Map();
+    const rowsByLabel = new Map();
+    for (const row of resolvedRows) {
+        const key = row.candidate.when.trim().toLowerCase();
+        const group = rowsByLabel.get(key) ?? [];
+        group.push(row);
+        rowsByLabel.set(key, group);
+    }
+    for (const rows of rowsByLabel.values()) {
+        const canonicalSets = new Set(rows.filter((row) => row.commands.length > 0)
+            .map((row) => JSON.stringify([...new Set(row.commands.map(({ command }) => command))].sort())));
+        if (canonicalSets.size > 1) {
+            const first = rows[0].candidate;
+            reject(state, first.when, first.commands.join(" · "), "conflicting_recipe_label");
+            continue;
+        }
+        for (const row of rows) {
+            for (const resolved of row.commands) {
+                const provenance = accepted.get(resolved.command) ?? [];
+                for (const pointer of resolved.provenance) {
+                    if (!provenance.some((entry) => JSON.stringify(entry) === JSON.stringify(pointer)))
+                        provenance.push(pointer);
+                }
+                accepted.set(resolved.command, provenance);
+            }
+        }
+    }
+    const commandOmitted = Math.max(0, accepted.size - MAX_COMMANDS) + state.candidateCommandOmitted;
+    const expectedCommands = [...accepted.entries()].slice(0, MAX_COMMANDS).map(([command, allProvenance]) => {
+        const provenance = allProvenance.slice(0, MAX_PROVENANCE);
+        return {
+            command,
+            source_provenance: provenance,
+            provenance_omitted_count: allProvenance.length - provenance.length,
+        };
+    });
+    const provenanceOmitted = expectedCommands.some((entry) => entry.provenance_omitted_count !== 0);
+    const hasOmissions = commandOmitted > 0 || provenanceOmitted
+        || state.rejectionOmitted > 0 || state.diagnosticOmitted > 0;
+    const hasProblems = state.rejections.length > 0 || state.diagnostics.length > 0 || hasOmissions;
+    return {
+        status: hasOmissions ? "partial" : expectedCommands.length === 0 ? "unavailable" : hasProblems ? "partial" : "available",
+        expected_commands: expectedCommands,
+        command_omitted_count: commandOmitted,
+        rejections: state.rejections,
+        rejection_omitted_count: state.rejectionOmitted,
+        diagnostics: state.diagnostics,
+        diagnostic_omitted_count: state.diagnosticOmitted,
+        resolution_policy: {
+            id: "agents_recipe_table_package_scripts_v1",
+            selection: "agents_recipe_table",
+            package_binding: "root_or_pnpm_c",
+            aliases: "resolve_before_conflicts",
+            node_arguments: "tokens_without_absolute_or_parent_paths",
+            missing_node_target: "reject",
+            execution: "never",
+        },
+    };
+}
+function readRecipeCandidates(state) {
+    const guidancePath = path.join(state.projectRoot, "AGENTS.md");
+    const sourceResult = readBoundedText(guidancePath, state, "AGENTS.md");
+    if ("reason" in sourceResult)
+        return [];
+    const source = sourceResult.text;
+    const lines = source.split(/\r?\n/);
+    const header = lines.findIndex((line) => line.trim() === "| When | Command |");
+    if (header < 0 || !/^\|\s*:?-+\s*\|\s*:?-+\s*\|$/.test((lines[header + 1] ?? "").trim())) {
+        diagnostic(state, "AGENTS.md recipe table '| When | Command |' is missing or malformed.");
+        return [];
+    }
+    const rows = [];
+    for (let index = header + 2; index < lines.length && lines[index].trim().startsWith("|"); index += 1) {
+        if (rows.length >= MAX_RECIPE_ROWS) {
+            diagnostic(state, `AGENTS.md recipe table exceeds ${MAX_RECIPE_ROWS} rows.`);
+            break;
+        }
+        const cells = lines[index].trim().slice(1, -1).split("|").map((cell) => cell.trim());
+        if (cells.length !== 2) {
+            diagnostic(state, `AGENTS.md recipe row ${index + 1} is malformed.`);
+            continue;
+        }
+        const [when, commandCell] = cells;
+        if (!VERIFICATION_LABEL.test(when))
+            continue;
+        if (!pointerStringIsSafe(when)) {
+            reject(state, when, commandCell, "source_pointer_too_long");
+            continue;
+        }
+        const commands = inlineCommands(commandCell);
+        if (commands === null || commands.length === 0) {
+            reject(state, when, commandCell, "command_cell_malformed");
+            continue;
+        }
+        rows.push({ when, commands, line: index + 1 });
+    }
+    return rows;
+}
+function inlineCommands(cell) {
+    const matches = [...cell.matchAll(/`([^`\r\n]+)`/g)];
+    if (matches.length === 0)
+        return null;
+    const remainder = cell.replace(/`[^`\r\n]+`/g, "").replaceAll("·", "").trim();
+    return remainder === "" ? matches.map((match) => match[1].trim()) : null;
+}
+function resolveCommand(state, candidate, command) {
+    const when = candidate.when;
+    if (!pointerStringIsSafe(command))
+        return rejected(state, when, command, "source_pointer_too_long");
+    if (/<[^>]+>|\.\.\.|…/.test(command))
+        return rejected(state, when, command, "placeholder_not_allowed");
+    if (/\|\||[;|><$()'"`\\]/.test(command))
+        return rejected(state, when, command, "unsupported_syntax");
+    const segments = command.split(/\s+&&\s+/);
+    if (segments.length > 2 || segments.some((segment) => segment.length === 0)) {
+        return rejected(state, when, command, "unsupported_command_chain");
+    }
+    const canonical = [];
+    const provenance = [{
+            source_family: "project_guidance",
+            path: "AGENTS.md",
+            line: candidate.line,
+            recipe_label: when,
+            recipe_command: command,
+        }];
+    for (const segment of segments) {
+        const tokens = segment.trim().split(/\s+/);
+        if (tokens.some((token) => !SAFE_TOKEN.test(token)))
+            return rejected(state, when, command, "unsupported_syntax");
+        if (tokens[0] === "pnpm") {
+            const resolved = resolvePnpm(state, tokens);
+            if (typeof resolved === "string")
+                return rejected(state, when, command, resolved);
+            canonical.push(resolved.command);
+            provenance.push(...resolved.provenance);
+            continue;
+        }
+        if (tokens[0] === "node") {
+            const resolved = resolveNode(state, tokens);
+            if ("reason" in resolved)
+                return rejected(state, when, command, resolved.reason);
+            canonical.push(resolved.command);
+            provenance.push(...resolved.provenance);
+            continue;
+        }
+        return rejected(state, when, command, "unsupported_or_missing_executable");
+    }
+    return {
+        command: canonical.join(" && "),
+        provenance,
+    };
+}
+function resolvePnpm(state, tokens) {
+    let directory = ".";
+    let index = 1;
+    if (tokens[index] === "-C") {
+        directory = tokens[index + 1] ?? "";
+        index += 2;
+    }
+    if (tokens[index] === "run")
+        index += 1;
+    const script = tokens[index];
+    if (!script || index !== tokens.length - 1)
+        return "unsupported_pnpm_syntax";
+    if (!SCRIPT_NAME.test(script) || !pointerStringIsSafe(script))
+        return "unsupported_pnpm_script_name";
+    const packageRoot = resolveInsideRoot(state.projectRoot, directory);
+    if (!packageRoot)
+        return "package_path_outside_project";
+    const manifestPath = path.join(packageRoot, "package.json");
+    const manifestRelative = relativeProjectPath(state.projectRoot, manifestPath);
+    if (!pointerStringIsSafe(manifestRelative))
+        return "source_pointer_too_long";
+    const manifestResult = readBoundedText(manifestPath, state, manifestRelative, false);
+    if ("reason" in manifestResult) {
+        return manifestResult.reason === "missing" ? "package_manifest_unavailable" : "package_path_unsafe";
+    }
+    const manifestSource = manifestResult.text;
+    let manifest;
+    try {
+        const parsed = JSON.parse(manifestSource);
+        const scripts = parsed.scripts && typeof parsed.scripts === "object" && !Array.isArray(parsed.scripts)
+            ? parsed.scripts
+            : {};
+        manifest = {
+            scripts,
+        };
+    }
+    catch {
+        return "package_manifest_malformed";
+    }
+    const alias = resolveScriptAlias(manifest.scripts, script);
+    if (typeof alias === "string")
+        return alias;
+    const prefix = directory === "." ? "pnpm" : `pnpm -C ${relativeProjectPath(state.projectRoot, packageRoot)}`;
+    const canonicalCommand = `${prefix} run ${alias.canonical}`;
+    if (!pointerStringIsSafe(canonicalCommand) || alias.chain.some((name) => !pointerStringIsSafe(`scripts.${name}`))) {
+        return "source_pointer_too_long";
+    }
+    return {
+        command: canonicalCommand,
+        provenance: alias.chain.map((name) => ({
+            source_family: "package_manifest",
+            path: manifestRelative,
+            field: `scripts.${name}`,
+        })),
+    };
+}
+function resolveScriptAlias(scripts, requested) {
+    const chain = [];
+    let current = requested;
+    for (let depth = 0; depth <= MAX_ALIAS_DEPTH; depth += 1) {
+        if (chain.includes(current))
+            return "package_script_alias_cycle";
+        if (!SCRIPT_NAME.test(current) || !pointerStringIsSafe(current))
+            return "unsupported_pnpm_script_name";
+        chain.push(current);
+        const body = scripts[current];
+        if (typeof body !== "string")
+            return "package_script_missing";
+        const alias = /^pnpm\s+(?:run\s+)?(\S+)$/.exec(body.trim());
+        if (!alias)
+            return { canonical: current, chain };
+        if (!SCRIPT_NAME.test(alias[1]))
+            return { canonical: current, chain };
+        current = alias[1];
+    }
+    return "package_script_alias_depth_exceeded";
+}
+function resolveNode(state, tokens) {
+    if (tokens.length < 2)
+        return { reason: "unsupported_node_syntax" };
+    const target = resolveInsideRoot(state.projectRoot, tokens[1]);
+    if (!target || path.isAbsolute(tokens[1]))
+        return { reason: "node_target_outside_project" };
+    const targetStatus = projectFileStatus(state, target);
+    if (targetStatus === "unsafe")
+        return { reason: "node_target_path_unsafe" };
+    if (targetStatus === "missing")
+        return { reason: "node_target_missing" };
+    if (!nodeArgumentsAreSafe(tokens.slice(2)))
+        return { reason: "node_argument_path_unsafe" };
+    return {
+        command: `node ${relativeProjectPath(state.projectRoot, target)}${tokens.length > 2 ? ` ${tokens.slice(2).join(" ")}` : ""}`,
+        provenance: [],
+    };
+}
+function nodeArgumentsAreSafe(args) {
+    return args.every((argument) => {
+        const value = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : argument;
+        if (!value)
+            return true;
+        const normalized = value.replaceAll("\\", "/");
+        return !path.posix.isAbsolute(normalized)
+            && !path.win32.isAbsolute(value)
+            && !normalized.split("/").includes("..");
+    });
+}
+function readBoundedText(filePath, state, label, reportDiagnostic = true) {
+    if (state.validatedRoot === null)
+        return { reason: "unsafe" };
+    const relative = relativeProjectPath(state.projectRoot, filePath);
+    try {
+        assertValidatedProjectRoot(state.validatedRoot);
+        const pathSnapshot = snapshotProjectPath(state.validatedRoot.path, relative, "file");
+        if (pathSnapshot.kind === "missing") {
+            if (reportDiagnostic)
+                diagnostic(state, `${label} is missing or rejected by bounded path safety (missing).`);
+            return { reason: "missing" };
+        }
+        if (pathSnapshot.kind === "unsafe") {
+            const reason = pathSnapshot.reason === "symlink" ? "symlink" : "unsafe";
+            if (reportDiagnostic)
+                diagnostic(state, `${label} is missing or rejected by bounded path safety (${reason}).`);
+            return { reason };
+        }
+        if (pathSnapshot.leaf.size > BigInt(MAX_SOURCE_BYTES)) {
+            if (reportDiagnostic)
+                diagnostic(state, `${label} is not a bounded regular file.`);
+            return { reason: "unsafe" };
+        }
+        if (!projectPathIsStable(pathSnapshot))
+            return { reason: "unsafe" };
+        const fileSnapshot = readProjectFileSnapshot(state.validatedRoot, relative);
+        if (fileSnapshot.kind !== "file" || fileSnapshot.bytes.byteLength > MAX_SOURCE_BYTES) {
+            const reason = fileSnapshot.kind === "missing"
+                ? "missing"
+                : fileSnapshot.kind === "unsafe" && fileSnapshot.reason === "symlink" ? "symlink" : "unsafe";
+            if (reportDiagnostic)
+                diagnostic(state, `${label} is missing or rejected by bounded path safety (${reason}).`);
+            return { reason };
+        }
+        return { text: fileSnapshot.bytes.toString("utf8") };
+    }
+    catch {
+        if (reportDiagnostic)
+            diagnostic(state, `${label} is missing or unreadable.`);
+        return { reason: "unsafe" };
+    }
+}
+function projectFileStatus(state, filePath) {
+    if (state.validatedRoot === null)
+        return "unsafe";
+    try {
+        assertValidatedProjectRoot(state.validatedRoot);
+        const snapshot = snapshotProjectPath(state.validatedRoot.path, relativeProjectPath(state.projectRoot, filePath), "file");
+        if (snapshot.kind === "missing")
+            return "missing";
+        if (snapshot.kind === "unsafe" || !projectPathIsStable(snapshot))
+            return "unsafe";
+        assertValidatedProjectRoot(state.validatedRoot);
+        return "file";
+    }
+    catch {
+        return "unsafe";
+    }
+}
+function resolveInsideRoot(root, relative) {
+    if (!relative || path.isAbsolute(relative) || relative.split(/[\\/]/).includes(".."))
+        return null;
+    const resolved = path.resolve(root, relative);
+    return isInside(root, resolved) ? resolved : null;
+}
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== "..");
+}
+function relativeProjectPath(root, target) {
+    return path.relative(root, target).split(path.sep).join("/") || ".";
+}
+function reject(state, when, command, reason) {
+    if (state.rejections.length < MAX_REJECTIONS) {
+        state.rejections.push({
+            when: pointerStringIsSafe(when) ? when : "<overlong-label>",
+            command: pointerStringIsSafe(command) ? command : "<overlong-command>",
+            reason,
+        });
+    }
+    else
+        state.rejectionOmitted += 1;
+}
+function rejected(state, when, command, reason) {
+    reject(state, when, command, reason);
+    return null;
+}
+function diagnostic(state, message) {
+    const bounded = pointerStringIsSafe(message) ? message : "Verification diagnostic exceeded its string bound.";
+    if (state.diagnostics.length < MAX_DIAGNOSTICS)
+        state.diagnostics.push(bounded);
+    else
+        state.diagnosticOmitted += 1;
+}
+function pointerStringIsSafe(value) {
+    return [...value].length <= MAX_POINTER_STRING;
+}

package/dist/cli/capabilityContext/shared.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import { firstPresent } from "../stateQuery.js";
+import { CAPABILITY_NAMES } from "./types.js";
+import { preCutoverCommand } from "../preCutoverCommand.js";
+export { CAPABILITY_NAMES };
+export function isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function entryStatus(entry, def = "open") {
+    const raw = "status" in entry ? entry.status : def;
+    return String(raw || def).toLowerCase();
+}
+export function pyRepr(value) {
+    return value.includes("'") && !value.includes('"') ? `"${value}"` : `'${value}'`;
+}
+export function validatePrimeCapability(capability) {
+    if (!CAPABILITY_NAMES.includes(capability)) {
+        const valid = CAPABILITY_NAMES.join(", ");
+        throw new Error(`unsupported capability ${pyRepr(capability)}; valid capabilities: ${valid}. ` +
+            `Example: ${preCutoverCommand("prime --context plan --format json")}`);
+    }
+}
+export function appendUnique(items, value) {
+    if (value && !items.includes(value))
+        items.push(value);
+}
+export function taskRef(task) {
+    const record = task.record && typeof task.record === "object" && !Array.isArray(task.record) ? task.record : task;
+    return {
+        id: task.id ?? null,
+        artifact: task.artifact ?? "plan",
+        name: firstPresent(record, ["name", "title"], ""),
+        status: entryStatus(record, "pending"),
+    };
+}
+export function sourceProvenance(sourceFamily, command, field = null) {
+    const provenance = { source_family: sourceFamily, command };
+    if (field)
+        provenance.field = field;
+    return provenance;
+}
+export function docsConventions(docs) {
+    const conventions = docs.conventions;
+    return conventions && typeof conventions === "object" && !Array.isArray(conventions) ? conventions : {};
+}
+export function hasRecordedValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === "object")
+        return Object.keys(value).length > 0;
+    return true;
+}
+export function capabilityContextAppSummary(appHome, bundle) {
+    const caveats = [];
+    if (appHome.status !== "up_to_date") {
+        caveats.push("Agentera app files are not up to date; this is a caveat, not approval to repair or update app files.");
+    }
+    return {
+        status: appHome.status,
+        home: appHome.home,
+        source: appHome.source,
+        managed_app_root: appHome.managed_app_root,
+        user_data_root: appHome.user_data_root,
+        expected_version: bundle.expectedVersion,
+        caveats,
+    };
+}
+export function uniqueList(items) {
+    const out = [];
+    for (const item of items)
+        if (!out.includes(item))
+            out.push(item);
+    return out;
+}

package/dist/cli/capabilityContext/slim.js

@@ -0,0 +1,152 @@
+import { asList } from "../stateQuery.js";
+import { truncateCodePoints } from "../../core/text.js";
+function pickObject(value, keys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const source = value;
+    const compact = {};
+    for (const key of keys)
+        if (key in source)
+            compact[key] = source[key];
+    return compact;
+}
+export function slimBenchmarkContext(value) {
+    const compact = { capability: value.capability ?? "optimize" };
+    compact.benchmark_source = pickObject(value.benchmark_source, ["status", "source_provenance", "caveats"]);
+    compact.latest_report = pickObject(value.latest_report, ["status", "source_label", "non_empty_evidence_present", "status_counts", "caveats"]);
+    compact.history_summary = pickObject(value.history_summary, ["status", "source_label", "non_empty_evidence_present", "rows", "caveats"]);
+    compact.runtime_coverage = pickObject(value.runtime_coverage, ["status", "source_label", "non_empty_evidence_present", "status_counts", "caveats"]);
+    compact.state_access_metrics = pickObject(value.state_access_metrics, [
+        "status", "total_state_sequences", "state_sequences_with_raw_after_cli", "state_sequences_with_redundant_raw_access",
+        "raw_after_cli_sequence_rate", "redundant_raw_sequence_rate", "caveats",
+    ]);
+    compact.token_impact = pickObject(value.token_impact, ["status", "estimated_tokens_saved_vs_previous", "caveats"]);
+    compact.comparison = pickObject(value.comparison, ["status", "rows", "caveats"]);
+    compact.recommendation = pickObject(value.recommendation, ["status", "action", "rationale", "caveats"]);
+    compact.manual_refresh = pickObject(value.manual_refresh, ["command", "source_provenance"]);
+    compact.privacy_boundary = pickObject(value.privacy_boundary, ["status", "excluded", "caveats"]);
+    compact.state_family_caveats = value.state_family_caveats ?? [];
+    compact.fallback_commands = value.fallback_commands ?? [];
+    compact.source_contract = value.source_contract ?? {};
+    return compact;
+}
+export function compactTaskSummaryForSlim(task) {
+    if (!task || typeof task !== "object" || Array.isArray(task))
+        return task;
+    return {
+        id: task.id ?? null,
+        artifact: task.artifact ?? "plan",
+        name: task.name ?? null,
+        status: task.status ?? null,
+        depends_on: task.depends_on ?? null,
+        acceptance_count: task.acceptance_summary && typeof task.acceptance_summary === "object" ? task.acceptance_summary.count ?? null : null,
+        evidence_count: task.evidence_summary && typeof task.evidence_summary === "object" ? task.evidence_summary.count ?? null : null,
+        blocked_reasons: task.blocked_reasons ?? null,
+    };
+}
+export function compactProgressVerification(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const out = {};
+    for (const key of [
+        "status", "source_provenance", "cycle", "verified_present",
+        "non_empty_evidence_present", "non_empty_evidence_fields", "latest_progress_verification_pointer", "caveats",
+    ]) {
+        if (key in value)
+            out[key] = value[key];
+    }
+    return out;
+}
+export function slimOrchestrationContext(value) {
+    const compact = { ...value };
+    const taskQueue = value.task_queue && typeof value.task_queue === "object" && !Array.isArray(value.task_queue) ? value.task_queue : {};
+    const ready = asList(taskQueue.dependency_ready_tasks);
+    const blocked = asList(taskQueue.blocked_tasks);
+    const retrieval = taskQueue.retrieval ?? null;
+    compact.task_queue = {
+        total: taskQueue.total ?? null,
+        complete: taskQueue.complete ?? null,
+        superseded: taskQueue.superseded ?? null,
+        status_counts: taskQueue.status_counts ?? {},
+        dependency_ready_tasks: ready.slice(0, 10).map((t) => compactTaskSummaryForSlim(t)),
+        blocked_tasks: blocked.slice(0, 10).map((t) => compactTaskSummaryForSlim(t)),
+        dependency_ready_count: ready.length,
+        blocked_count: blocked.length,
+        ...(ready.length > 10 ? { dependency_ready_omission: { omitted: true, omitted_count: ready.length - 10, omission_reason: "startup_detail_capacity", retrieval } } : {}),
+        ...(blocked.length > 10 ? { blocked_omission: { omitted: true, omitted_count: blocked.length - 10, omission_reason: "startup_detail_capacity", retrieval } } : {}),
+    };
+    compact.progress_verification = compactProgressVerification(value.progress_verification);
+    const summaries = asList(value.task_summaries);
+    compact.task_summaries = summaries.slice(0, 10).map((t) => compactTaskSummaryForSlim(t));
+    if (summaries.length > 10)
+        compact.task_summaries_omission = { omitted: true, omitted_count: summaries.length - 10, omission_reason: "startup_detail_capacity", retrieval };
+    return compact;
+}
+export function truncateContextText(value, maxChars = 240) {
+    if (typeof value !== "string")
+        return value;
+    return truncateCodePoints(value, maxChars, "\u2026", true);
+}
+export function compactItemsState(value, maxItems = 3, maxChars = 180) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const compact = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (!["items", "attributed_items", "summary"].includes(key))
+            compact[key] = item;
+    }
+    const items = value.items;
+    if (Array.isArray(items)) {
+        compact.item_count = items.length;
+        compact.items = items.slice(0, maxItems).map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? Object.fromEntries(Object.entries(item).map(([k, v]) => [k, truncateContextText(v, maxChars)]))
+            : truncateContextText(item, maxChars));
+        compact.truncated_item_count = Math.max(items.length - maxItems, 0);
+    }
+    const attributed = value.attributed_items;
+    if (Array.isArray(attributed))
+        compact.attributed_item_count = attributed.length;
+    if (typeof value.summary === "string") {
+        compact.summary_present = true;
+        compact.summary_excerpt = truncateContextText(value.summary, maxChars);
+    }
+    return compact;
+}
+export function compactVersionChecks(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const compact = {};
+    for (const key of ["status", "allowed_status_values", "source_provenance", "caveats"]) {
+        if (key in value)
+            compact[key] = value[key];
+    }
+    const checks = value.checks;
+    if (Array.isArray(checks)) {
+        compact.checks = checks.map((check) => {
+            const out = {};
+            for (const key of ["name", "status", "refresh_performed", "remote_checks_performed", "registry_checks_performed"]) {
+                if (check && typeof check === "object" && !Array.isArray(check) && key in check) {
+                    const c = check;
+                    out[key] = c[key];
+                }
+            }
+            return out;
+        });
+    }
+    return compact;
+}
+export function slimEvidenceContext(value) {
+    const compact = { ...value };
+    compact.residual_risks = compactItemsState(value.residual_risks, 5, 180);
+    compact.todo_state = compactItemsState(value.todo_state, 3, 180);
+    compact.progress_verification = compactProgressVerification(value.progress_verification);
+    compact.version_checks = compactVersionChecks(value.version_checks);
+    return compact;
+}
+export function slimCloseoutContext(value) {
+    const compact = { ...value };
+    compact.benchmark_evidence = compactItemsState(value.benchmark_evidence, 0, 220);
+    compact.todo_blockers = compactItemsState(value.todo_blockers, 3, 160);
+    compact.progress_evidence = compactProgressVerification(value.progress_evidence);
+    return compact;
+}