agentera 3.0.0-dev.8 → 3.0.0-dev.81

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

@@ -1,6 +1,7 @@
 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 {
@@ -21,7 +22,7 @@ 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: agentera prime --context plan --format json");
+            `Example: ${preCutoverCommand("prime --context plan --format json")}`);
     }
 }
 export function appendUnique(items, value) {
@@ -29,7 +30,13 @@ export function appendUnique(items, value) {
         items.push(value);
 }
 export function taskRef(task) {
-    return { number: task.number ?? null, name: firstPresent(task, ["name", "title"], ""), status: entryStatus(task, "pending") };
+    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 };
@@ -52,9 +59,6 @@ export function hasRecordedValue(value) {
         return Object.keys(value).length > 0;
     return true;
 }
-export function fallbackStatePointer(artifactId, command) {
-    return { status: "fallback_only", artifact_id: artifactId, fallback_command: command, raw_artifact_reads_required: false };
-}
 export function capabilityContextAppSummary(appHome, bundle) {
     const caveats = [];
     if (appHome.status !== "up_to_date") {
@@ -70,20 +74,6 @@ export function capabilityContextAppSummary(appHome, bundle) {
         caveats,
     };
 }
-export function capabilityContextProfileSummary(profile) {
-    const caveats = [];
-    if (profile.status !== "loaded")
-        caveats.push("profile-derived state is unavailable in prime --context response.");
-    else if (profile.stale === true)
-        caveats.push("profile-derived state is stale; this is a caveat, not approval to refresh profile state.");
-    const summary = {};
-    for (const key of ["status", "path", "stale", "days_since_generated", "stale_threshold_days", "suggested_action"]) {
-        if (key in profile)
-            summary[key] = profile[key];
-    }
-    summary.caveats = caveats;
-    return summary;
-}
 export function uniqueList(items) {
     const out = [];
     for (const item of items)
@@ -91,4 +81,3 @@ export function uniqueList(items) {
             out.push(item);
     return out;
 }
-//# sourceMappingURL=shared.js.map

package/dist/cli/capabilityContext/slim.js

@@ -1,9 +1,41 @@
 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 {
-        number: task.number ?? null,
+        id: task.id ?? null,
+        artifact: task.artifact ?? "plan",
         name: task.name ?? null,
         status: task.status ?? null,
         depends_on: task.depends_on ?? null,
@@ -28,19 +60,32 @@ export function compactProgressVerification(value) {
 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,
-        dependency_ready_tasks: asList(taskQueue.dependency_ready_tasks).map((t) => compactTaskSummaryForSlim(t)),
-        blocked_tasks: asList(taskQueue.blocked_tasks).map((t) => compactTaskSummaryForSlim(t)),
+        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);
-    compact.task_summaries = asList(value.task_summaries).map((t) => compactTaskSummaryForSlim(t));
+    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" || value.length <= maxChars)
+    if (typeof value !== "string")
         return value;
-    return value.slice(0, maxChars - 1).replace(/\s+$/, "") + "\u2026";
+    return truncateCodePoints(value, maxChars, "\u2026", true);
 }
 export function compactItemsState(value, maxItems = 3, maxChars = 180) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -92,7 +137,7 @@ export function compactVersionChecks(value) {
 }
 export function slimEvidenceContext(value) {
     const compact = { ...value };
-    compact.residual_risks = compactItemsState(value.residual_risks, 15, 180);
+    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);
@@ -105,4 +150,3 @@ export function slimCloseoutContext(value) {
     compact.progress_evidence = compactProgressVerification(value.progress_evidence);
     return compact;
 }
-//# sourceMappingURL=slim.js.map