@tea-agent/loop-agent 0.39.0-beta.12 → 0.39.0-beta.14

package/dist/executors/pi-executor.js

@@ -1023,15 +1023,19 @@ export function classifyPiFailure(input) {
         return "context-overflow";
     // Prefer explicit rate-limit / HTTP 429 before generic "limit" quota phrases.
     // Chinese gateways often say "请求频率已达到限制" without English "rate limit".
-    if (/rate.?limit|too many requests|\b429\b|请求频率|频率.*限制|rpm|tpm/.test(combined))
+    // Patterns need error-shaped context: the captured stream also contains
+    // serialized session events, where a bare "429" is an output-token counter,
+    // bare "rpm"/"tpm" are base64 substrings of encrypted reasoning, and bare
+    // "network" is a "no-network" UI state name.
+    if (/rate.?limit|too many requests|(?:http|status)[^\d]{0,4}429\b|"code"\s*:\s*"?429\b|(?:^|\n)429[\s:]|请求频率|频率.*限制|\b(?:rpm|tpm)\s*(?:limit|quota|exceeded)/.test(combined))
         return "rate-limit";
-    if (/quota|usage limit|reached.*limit|5\s*小时|5小时|insufficient_quota|billing/.test(combined))
+    if (/quota|usage limit|reached[^\n.]{0,60}limit|5\s*小时|5小时|insufficient_quota|billing/.test(combined))
         return "quota";
     if (/\bunauthorized\b|\bhttp\s*40[13]\b|invalid api key|authentication (?:failed|required|error)|auth(?:entication)? failed/.test(combined))
         return "auth";
-    if (/unknown provider|unknown model|model.*unavailable|provider.*unavailable|\bunavailable\b|overloaded|capacity|temporarily unavailable/.test(combined))
+    if (/unknown provider|unknown model|(?:provider|model|service|gateway)\s+(?:is\s+)?unavailable|overloaded|at capacity|temporarily unavailable/.test(combined))
         return "unavailable";
-    if (/network|econnreset|etimedout|socket hang up|connection reset|connection error|request timed out|dns|fetch failed/.test(combined))
+    if (/network\s*(?:error|failure|issue|timeout|unreachable|reset|abort)|networkerror|connection (?:reset|error|refused|closed|timed\s*out)|request timed out|socket hang up|econn\w*|etimedout|fetch failed|dns (?:error|failure|lookup failed)/.test(combined))
         return "network";
     if (input.exitCode === 0 && !input.assistantText.trim())
         return "empty-output";

package/dist/executors/pi-sdk-executor.js

@@ -1,9 +1,12 @@
 import { appendFile, mkdir } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { computeExtensionToolAllowlistExtras } from "./pi-extension-resolver.js";
 import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_ABORT_GRACE_MS, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, extractPiEventStopReason, extractAssistantTextFromPiJson, } from "./pi-executor.js";
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
+import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
 /** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
 export const PI_SDK_STALL_CONTINUE_MAX = 1;
 /**
@@ -215,15 +218,37 @@ async function createSdkSession(sdk, input, shared) {
     // Inject rate-limit-tolerant auto-retry settings for the session lifecycle.
     // Prefer SettingsManager.inMemory so harness runs do not depend on ~/.pi or
     // project .pi/settings.json being present/trusted.
+    const policy = parseCompactionPolicy();
+    const compaction = {
+        ...PI_RECOMMENDED_COMPACTION,
+        ...inMemoryCompactionSettings(policy),
+    };
     const settingsManager = typeof SettingsManager?.inMemory === "function"
         ? SettingsManager.inMemory({
             retry: {
                 ...PI_RECOMMENDED_RETRY,
                 provider: { ...PI_RECOMMENDED_RETRY.provider },
             },
-            compaction: { ...PI_RECOMMENDED_COMPACTION },
+            compaction,
         }, { projectTrusted: true })
         : undefined;
+    const nodeSessionId = `dag-${randomUUID()}`;
+    const controller = createCompactionController();
+    const siftEnabled = isDagSiftEnabled();
+    const sift = siftEnabled.enabled
+        ? createSiftBridgeState(parseSiftBridgeConfig({
+            sessionId: nodeSessionId,
+            defaultStashRoot: path.join(os.tmpdir(), "loop-agent-dag-sift"),
+        }))
+        : undefined;
+    if (sift)
+        sift.counters = controller.counters;
+    const pressureExtension = createContextPressureExtension({
+        name: "dag-pi-context-pressure",
+        policy,
+        controller,
+        sift,
+    });
     const loader = new DefaultResourceLoader({
         cwd: input.cwd,
         agentDir,
@@ -233,6 +258,7 @@ async function createSdkSession(sdk, input, shared) {
         ...(input.additionalExtensionPaths && input.additionalExtensionPaths.length > 0
             ? { additionalExtensionPaths: input.additionalExtensionPaths }
             : {}),
+        ...(pressureExtension ? { extensionFactories: [pressureExtension] } : {}),
         ...(settingsManager ? { settingsManager } : {}),
         appendSystemPromptOverride: (base) => [
             ...base,
@@ -247,10 +273,12 @@ async function createSdkSession(sdk, input, shared) {
     // extras into the create-time allowlist; protected builtins, the deny
     // surface, and write-capable extension tools never join.
     const extensionToolExtras = [];
-    if (input.additionalExtensionPaths &&
-        input.additionalExtensionPaths.length > 0) {
-        const registered = collectLoaderExtensionToolNames(loader);
-        extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    const registered = collectLoaderExtensionToolNames(loader);
+    extensionToolExtras.push(...computeExtensionToolAllowlistExtras(registered.map((name) => ({ name })), input.toolNames));
+    if (siftEnabled.enabled &&
+        !extensionToolExtras.includes(SIFT_RETRIEVE_TOOL_NAME) &&
+        !input.toolNames.includes(SIFT_RETRIEVE_TOOL_NAME)) {
+        extensionToolExtras.push(...computeExtensionToolAllowlistExtras([{ name: SIFT_RETRIEVE_TOOL_NAME }], input.toolNames));
     }
     const sessionToolNames = [...input.toolNames, ...extensionToolExtras];
     if (input.requireWriterCustomTools) {

package/dist/executors/shell-executor.js

@@ -42,11 +42,11 @@ import { materializeBackendTestExecutionContract } from "../workflows/dag/backen
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
 import { frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
 import { backendTestGapDocSchema, ingestBackendTestGap, } from "../workflows/dag/backend-test-gap-fill.js";
-import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
+import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, classifyBackendTestCorrespondenceRepair, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, markdownFiles, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, summarizeBackendTestExclusions, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -880,26 +880,49 @@ async function executeBackendTestPipeline(input, meta) {
                 const correspondenceFactsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-initial.json");
                 await writeFile(correspondenceFactsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
                 outputs.push(`initialCorrespondence=${correspondenceReportPath}`, `initialCorrespondenceFacts=${correspondenceFactsPath}`);
-                if (correspondence.facts.status === "FAIL" && facts.status === "PASS") {
-                    const correspondenceRepairPaths = Array.from(new Set(correspondence.facts.entries
-                        .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                        .flatMap((entry) => [entry.expectedScript, ...entry.actualScripts])
-                        .filter((candidate) => candidate.startsWith("testcase/") && candidate.endsWith(".py")))).sort();
-                    if (correspondenceRepairPaths.length > 0) {
-                        facts.status = "REPAIRABLE";
-                        facts.repairEligible = true;
-                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...correspondenceRepairPaths])).sort();
+                if (correspondence.facts.status === "FAIL") {
+                    const repair = classifyBackendTestCorrespondenceRepair(correspondence.facts, backendLayout);
+                    if (repair.markdownBlockingEntries.length > 0) {
+                        facts.status = "BLOCKED";
+                        facts.repairEligible = false;
+                        facts.repairPaths = [];
                         facts.findings.push({
-                            kind: "markdown-pytest-correspondence",
+                            kind: "markdown-correspondence-contract",
                             classification: "test-asset-defect",
-                            repairability: "repairable",
-                            detail: correspondence.facts.entries
-                                .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                                .flatMap((entry) => entry.findings)
+                            repairability: "blocked",
+                            detail: repair.markdownBlockingEntries
+                                .map((entry) => `${entry.caseId ?? "unknown Case"}: ${entry.reasonCodes.join(", ")}`)
                                 .join("; ")
-                                .slice(0, 12_000) || "Markdown-to-pytest correspondence is incomplete",
+                                .slice(0, 12_000),
                         });
                     }
+                    else if (repair.pytestRepairPaths.length > 0 &&
+                        (facts.status === "PASS" || facts.status === "REPAIRABLE")) {
+                        facts.status = "REPAIRABLE";
+                        facts.repairEligible = true;
+                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...repair.pytestRepairPaths])).sort();
+                        const repairEntries = correspondence.facts.entries.filter((entry) => repair.pytestRepairEntries.some((candidate) => candidate.caseId === entry.caseId));
+                        for (const entry of repairEntries.slice(0, 40)) {
+                            const classified = repair.pytestRepairEntries.find((candidate) => candidate.caseId === entry.caseId);
+                            facts.findings.push({
+                                kind: "markdown-pytest-correspondence",
+                                classification: "test-asset-defect",
+                                repairability: "repairable",
+                                detail: entry.findings.join("; ").slice(0, 2_000) || "Markdown-to-pytest correspondence is incomplete",
+                                ...(entry.caseId ? { caseId: entry.caseId } : {}),
+                                reasonCodes: classified?.reasonCodes ?? [],
+                                repairPaths: classified?.paths ?? [],
+                                payloadExpectedPaths: Array.from(new Set([
+                                    ...entry.payloadAssessment.requiredPaths,
+                                    ...entry.payloadAssessment.allowedPaths,
+                                ])).sort(),
+                                payloadObservedPaths: entry.payloadAssessment.observedPaths,
+                                payloadMissingPaths: entry.payloadAssessment.missingPaths,
+                                payloadUnexpectedPaths: entry.payloadAssessment.unexpectedPaths,
+                                payloadEnumMismatches: entry.payloadAssessment.enumMismatches,
+                            });
+                        }
+                    }
                 }
             }
             catch (error) {
@@ -922,6 +945,19 @@ async function executeBackendTestPipeline(input, meta) {
                     collectedItemCount: facts.collectedItemCount,
                     missingMappedScripts: facts.missingMappedScripts,
                     repairPaths: facts.repairPaths,
+                    repairFindings: facts.findings.map((finding) => ({
+                        kind: finding.kind,
+                        repairability: finding.repairability,
+                        detail: finding.detail,
+                        ...(finding.caseId ? { caseId: finding.caseId } : {}),
+                        ...(finding.reasonCodes ? { reasonCodes: finding.reasonCodes } : {}),
+                        ...(finding.repairPaths ? { repairPaths: finding.repairPaths } : {}),
+                        ...(finding.payloadExpectedPaths ? { payloadExpectedPaths: finding.payloadExpectedPaths } : {}),
+                        ...(finding.payloadObservedPaths ? { payloadObservedPaths: finding.payloadObservedPaths } : {}),
+                        ...(finding.payloadMissingPaths ? { payloadMissingPaths: finding.payloadMissingPaths } : {}),
+                        ...(finding.payloadUnexpectedPaths ? { payloadUnexpectedPaths: finding.payloadUnexpectedPaths } : {}),
+                        ...(finding.payloadEnumMismatches ? { payloadEnumMismatches: finding.payloadEnumMismatches } : {}),
+                    })),
                     factsPath: "contracts/backend-test-pytest-collection-initial.json",
                 }),
                 stderr: "",
@@ -1021,6 +1057,7 @@ async function executeBackendTestPipeline(input, meta) {
                 })
                 : { eligibleItemIds: effective.collectedItemIds, excludedItems: [] };
             const eligibilityInputHashes = Object.fromEntries((correspondence?.facts.inputFiles ?? []).map((item) => [item.path, item.sha256]));
+            const exclusionSummary = summarizeBackendTestExclusions(eligibility.excludedItems);
             const eligibilityFactsPath = path.join(meta.runDir, "contracts", "backend-test-execution-eligibility.json");
             await mkdir(path.dirname(eligibilityFactsPath), { recursive: true });
             await writeFile(eligibilityFactsPath, `${JSON.stringify({
@@ -1031,6 +1068,9 @@ async function executeBackendTestPipeline(input, meta) {
                 excludedItemCount: eligibility.excludedItems.length,
                 eligibleItemIds: eligibility.eligibleItemIds,
                 excludedItems: eligibility.excludedItems,
+                exclusionSummary,
+                pytestSpawned: false,
+                businessTestBodyExecutedCount: 0,
                 inputHashes: eligibilityInputHashes,
             }, null, 2)}\n`, "utf8");
             const eligibilityReportPath = await writeRunReport(meta.runDir, "backend-test-execution-eligibility.md", [
@@ -1043,6 +1083,10 @@ async function executeBackendTestPipeline(input, meta) {
                 `- Collected items: ${effective.collectedItemIds.length}`,
                 `- Eligible items: ${eligibility.eligibleItemIds.length}`,
                 `- Excluded items: ${eligibility.excludedItems.length}`,
+                `- Excluded Cases: ${exclusionSummary.excludedCaseCount}`,
+                `- Exclusion categories: ${Object.entries(exclusionSummary.excludedByReason).map(([category, count]) => `${category}=${count}`).join("; ") || "none"}`,
+                "- pytest spawned: false",
+                "- Business test bodies executed: 0",
                 "",
                 "## Excluded Items",
                 "",
@@ -1071,6 +1115,9 @@ async function executeBackendTestPipeline(input, meta) {
                     executionReadinessStatus: readiness.status,
                     eligibleItemCount: readiness.eligibleItemIds.length,
                     excludedItemCount: readiness.excludedItems.length,
+                    exclusionSummary: readiness.exclusionSummary,
+                    pytestSpawned: readiness.pytestSpawned,
+                    businessTestBodyExecutedCount: readiness.businessTestBodyExecutedCount,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
                     readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,
@@ -2224,6 +2271,21 @@ async function collectReviewRestartPhase(runDir, reviewNodeId) {
 }
 /** A+B (AC-009): deterministic §4.10 restart phase for a committed
  * `request_design_changes` fact. Mirrors the review collector. */
+/** Number of findings attached to the committed request_design_changes
+ * terminal fact (0 when absent) — used for the admission advisory. */
+async function collectDesignReviewFindingCount(runDir, designNodeId) {
+    try {
+        const records = await readTypedEventStoreFromJsonl(path.join(runDir, designNodeId, "design-typed-facts.jsonl"));
+        const request = records.find((record) => record.phase === "committed" &&
+            record.fact.kind ===
+                "request_design_changes");
+        const findings = (request?.fact).findings;
+        return Array.isArray(findings) ? findings.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 async function collectDesignRestartPhase(runDir, designNodeId) {
     try {
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, designNodeId, "design-typed-facts.jsonl"));
@@ -2540,21 +2602,30 @@ async function executeFrontendWriterAdmission(input, meta) {
     const shell = input.task.shell;
     const config = shell.frontendWriterAdmission;
     try {
-        // 1. Design verdict pass is a hard admission condition (M8 D2). In small
-        // topology the design review node is absent and the check is vacuous.
-        // The verdict is read from the committed typed design terminal fact, not
+        // 1. Design verdict handling (r12 policy change). The typed terminal
+        // verdict is read from the committed typed design terminal fact, not
         // from the legacy first-line VERDICT text protocol (AC-003/AC-004).
+        // A request_design_changes verdict no longer blocks writer admission:
+        // it is downgraded to an advisory that rides along in the admission
+        // receipt (and reaches implement via the review node's upstream
+        // context). Blocking is owned by the deterministic gates (prewrite,
+        // write guard) and the final code review. A missing typed terminal
+        // verdict still fails closed. In small topology the design review node
+        // is absent and the check is vacuous.
         let verdictPass = true;
-        let designRestartPhase;
+        let designAdvisory;
         if (config.designReviewFromNodeId) {
             const designKinds = await collectDesignTerminalKinds(meta.runDir, config.designReviewFromNodeId);
-            verdictPass =
-                designKinds.length === 1 && designKinds[0] === "approve_design";
-            // A+B (AC-009): request_design_changes issueCategory maps to the
-            // deterministic §4.10 restart phase; unknown fails closed to undefined.
-            designRestartPhase = verdictPass
-                ? undefined
-                : await collectDesignRestartPhase(meta.runDir, config.designReviewFromNodeId);
+            if (designKinds.length !== 1) {
+                verdictPass = false;
+            }
+            else if (designKinds[0] !== "approve_design") {
+                designAdvisory = {
+                    verdict: designKinds[0],
+                    restartPhase: await collectDesignRestartPhase(meta.runDir, config.designReviewFromNodeId),
+                    findingCount: await collectDesignReviewFindingCount(meta.runDir, config.designReviewFromNodeId),
+                };
+            }
         }
         // 2. Read the canonical contract + design-policy result.
         const contractRaw = await readRunDirJson(meta.runDir, "contracts/frontend-implementation-contract.json");
@@ -2630,10 +2701,8 @@ async function executeFrontendWriterAdmission(input, meta) {
             : [
                 ...admission.findings,
                 {
-                    code: "design-approval-request-revision",
-                    message: designRestartPhase !== undefined
-                        ? `design review typed terminal verdict is not approve_design (restartPhase=${designRestartPhase})`
-                        : "design review typed terminal verdict is not approve_design",
+                    code: "design-approval-missing",
+                    message: "design review typed terminal verdict missing or ambiguous (fail closed)",
                 },
             ];
         const classification = findings.length === 0 && admission.classification === "accepted"
@@ -2654,6 +2723,7 @@ async function executeFrontendWriterAdmission(input, meta) {
                 ? { baselineDebtPolicy: admission.baselineDebtPolicy }
                 : {}),
             findings,
+            ...(designAdvisory ? { designReviewAdvisory: designAdvisory } : {}),
             failureSource,
         });
         await writeDagRunJsonArtifact(meta.runDir, FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, result);

package/dist/governance/checks.js

@@ -8,6 +8,7 @@ import { buildTaskReadModel } from '../task/read-model.js';
 const SKIP_DIRS = new Set([
     '.git',
     '.harness',
+    '.scratch',
     'node_modules',
     'dist',
     'coverage',

package/dist/shared/pi-context-pressure/checkpoint.js

@@ -0,0 +1,116 @@
+const CHECKPOINT_MAX_BYTES = 12 * 1024;
+function boundText(value, maxChars) {
+    if (typeof value !== "string" || !value.trim())
+        return "";
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars - 1)}…`;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function extractLastUserGoal(messages) {
+    if (!Array.isArray(messages))
+        return "";
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = asRecord(messages[index]);
+        if (!message || message.role !== "user")
+            continue;
+        const content = message.content;
+        if (typeof content === "string")
+            return boundText(content, 800);
+        if (Array.isArray(content)) {
+            const texts = content
+                .map((block) => {
+                const rec = asRecord(block);
+                return typeof rec?.text === "string" ? rec.text : "";
+            })
+                .filter(Boolean);
+            if (texts.length > 0)
+                return boundText(texts.join("\n"), 800);
+        }
+    }
+    return "";
+}
+function extractTodos(details) {
+    const record = asRecord(details);
+    const todos = record?.todos ?? record?.items;
+    if (!Array.isArray(todos))
+        return "";
+    const lines = todos
+        .slice(0, 24)
+        .map((item) => {
+        const rec = asRecord(item);
+        const status = typeof rec?.status === "string" ? rec.status : "pending";
+        const content = typeof rec?.content === "string"
+            ? rec.content
+            : typeof rec?.title === "string"
+                ? rec.title
+                : "";
+        return content ? `- [${status}] ${content}` : "";
+    })
+        .filter(Boolean);
+    return boundText(lines.join("\n"), 1200);
+}
+function extractFileOps(fileOps) {
+    const record = asRecord(fileOps);
+    if (!record)
+        return "";
+    const parts = [];
+    for (const key of ["edited", "written", "read", "deleted", "ops"]) {
+        const value = record[key];
+        if (Array.isArray(value)) {
+            parts.push(`${key}: ${value
+                .slice(0, 20)
+                .map((item) => (typeof item === "string" ? item : JSON.stringify(item)))
+                .join(", ")}`);
+        }
+        else if (typeof value === "string" && value) {
+            parts.push(`${key}: ${value}`);
+        }
+    }
+    if (parts.length === 0) {
+        try {
+            return boundText(JSON.stringify(fileOps), 800);
+        }
+        catch {
+            return "";
+        }
+    }
+    return boundText(parts.join("\n"), 800);
+}
+export function buildOverflowCheckpoint(input) {
+    const preparation = input.preparation;
+    const firstKeptEntryId = typeof preparation?.firstKeptEntryId === "string" &&
+        preparation.firstKeptEntryId
+        ? preparation.firstKeptEntryId
+        : undefined;
+    const tokensBefore = typeof preparation?.tokensBefore === "number" &&
+        Number.isFinite(preparation.tokensBefore)
+        ? preparation.tokensBefore
+        : undefined;
+    if (!firstKeptEntryId || tokensBefore === undefined)
+        return undefined;
+    const sections = [
+        "Deterministic overflow checkpoint (no extra summary request).",
+        boundText(preparation?.previousSummary, 2000)
+            ? `Previous summary:\n${boundText(preparation?.previousSummary, 2000)}`
+            : "",
+        extractLastUserGoal(preparation?.messagesToSummarize)
+            ? `Latest user goal:\n${extractLastUserGoal(preparation?.messagesToSummarize)}`
+            : "",
+        extractTodos(input.todos) ? `Open todos:\n${extractTodos(input.todos)}` : "",
+        extractFileOps(preparation?.fileOps)
+            ? `File ops:\n${extractFileOps(preparation?.fileOps)}`
+            : "",
+        typeof input.lastError === "string" && input.lastError
+            ? `Latest error:\n${boundText(input.lastError, 400)}`
+            : "",
+        "Next step: continue the interrupted turn from the kept recent messages. Do not repeat completed file writes.",
+    ].filter(Boolean);
+    let summary = sections.join("\n\n");
+    if (Buffer.byteLength(summary, "utf8") > CHECKPOINT_MAX_BYTES) {
+        summary = `${summary.slice(0, CHECKPOINT_MAX_BYTES - 1)}…`;
+    }
+    return { summary, firstKeptEntryId, tokensBefore };
+}

package/dist/shared/pi-context-pressure/compaction-policy.js

@@ -0,0 +1,151 @@
+import { parseBoundedNumber, readContextPressureMode, } from "./env.js";
+export const PI_DEFAULT_RESERVE_TOKENS = 16_384;
+export const DEFAULT_TRAILING_BUDGET_TOKENS = 8_192;
+export const DEFAULT_SAFETY_MARGIN_TOKENS = 4_096;
+export const DEFAULT_MINIMUM_WORKING_SET = 32_768;
+export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
+export function parseCompactionPolicy(env = process.env) {
+    const diagnostics = [];
+    const modeResult = readContextPressureMode(env);
+    if (modeResult.diagnostic)
+        diagnostics.push(modeResult.diagnostic);
+    const k = parseBoundedNumber(env.HARNESS_CONTEXT_GATEWAY_K, 1, 1, 8);
+    if (k.diagnostic)
+        diagnostics.push(k.diagnostic);
+    const trailing = parseBoundedNumber(env.HARNESS_CONTEXT_TRAILING_BUDGET_TOKENS, DEFAULT_TRAILING_BUDGET_TOKENS, 256, 128_000);
+    if (trailing.diagnostic)
+        diagnostics.push(trailing.diagnostic);
+    const safety = parseBoundedNumber(env.HARNESS_CONTEXT_SAFETY_MARGIN_TOKENS, DEFAULT_SAFETY_MARGIN_TOKENS, 0, 64_000);
+    if (safety.diagnostic)
+        diagnostics.push(safety.diagnostic);
+    const explicit = env.HARNESS_COMPACTION_RESERVE_TOKENS;
+    const explicitReserve = explicit === undefined || explicit.trim() === ""
+        ? undefined
+        : parseBoundedNumber(explicit, PI_DEFAULT_RESERVE_TOKENS, 1_024, 1_000_000);
+    if (explicitReserve?.diagnostic)
+        diagnostics.push(explicitReserve.diagnostic);
+    return {
+        mode: modeResult.mode,
+        k: k.value,
+        trailingBudgetTokens: trailing.value,
+        safetyMarginTokens: safety.value,
+        minimumWorkingSet: DEFAULT_MINIMUM_WORKING_SET,
+        ...(explicitReserve ? { explicitReserveTokens: explicitReserve.value } : {}),
+        diagnostics,
+    };
+}
+export function deriveEffectiveWindow(contextWindow, policy) {
+    const W = Math.floor(contextWindow);
+    if (!Number.isFinite(W) || W <= 0) {
+        return {
+            recommendedReserve: PI_DEFAULT_RESERVE_TOKENS,
+            triggerTokens: 0,
+            fallback: true,
+        };
+    }
+    if (policy.explicitReserveTokens !== undefined) {
+        const recommendedReserve = Math.min(Math.max(policy.explicitReserveTokens, 1), Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: false,
+        };
+    }
+    const rawTrigger = Math.floor(W / policy.k) -
+        policy.trailingBudgetTokens -
+        policy.safetyMarginTokens;
+    const rawReserve = W - rawTrigger;
+    const maxReserve = Math.max(1, W - policy.minimumWorkingSet);
+    if (!Number.isFinite(rawTrigger) ||
+        !Number.isFinite(rawReserve) ||
+        maxReserve < PI_DEFAULT_RESERVE_TOKENS) {
+        const recommendedReserve = Math.min(PI_DEFAULT_RESERVE_TOKENS, Math.max(1, W - 1));
+        return {
+            recommendedReserve,
+            triggerTokens: Math.max(0, W - recommendedReserve),
+            fallback: true,
+        };
+    }
+    const recommendedReserve = Math.min(Math.max(PI_DEFAULT_RESERVE_TOKENS, rawReserve), maxReserve);
+    return {
+        recommendedReserve,
+        triggerTokens: Math.max(0, W - recommendedReserve),
+        fallback: false,
+    };
+}
+export function conservativeTokenEstimate(text, imageCount = 0) {
+    const chars = Array.from(text);
+    let cjk = 0;
+    let other = 0;
+    for (const char of chars) {
+        if (/\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}/u.test(char)) {
+            cjk += 1;
+        }
+        else {
+            other += 1;
+        }
+    }
+    const utf8 = Buffer.byteLength(text, "utf8");
+    const fromChars = cjk + Math.ceil(other / 2);
+    const fromBytes = Math.ceil(utf8 / 2);
+    return (Math.max(fromChars, fromBytes, Math.ceil(chars.length / 2)) +
+        Math.max(0, imageCount) * 1024);
+}
+export function projectPromptPressure(input) {
+    if (input.currentContextTokens === null ||
+        input.currentContextTokens === undefined ||
+        !Number.isFinite(input.currentContextTokens)) {
+        return { projected: 0, usageUnavailable: true };
+    }
+    return {
+        projected: Math.max(0, input.currentContextTokens) +
+            conservativeTokenEstimate(input.promptText, input.imageCount ?? 0),
+        usageUnavailable: false,
+    };
+}
+function isExplicitlyDisabled(manager) {
+    const project = manager.getProjectSettings?.()?.compaction?.enabled;
+    const global = manager.getGlobalSettings?.()?.compaction?.enabled;
+    return project === false || (project === undefined && global === false);
+}
+export function applyProcessCompactionOverride(manager, input) {
+    if (!manager?.applyOverrides || input.policy.mode === "off") {
+        return { applied: false };
+    }
+    const explicitOff = input.policy.mode === "safe" && isExplicitlyDisabled(manager);
+    const enabled = input.policy.mode === "strict" ? true : explicitOff ? false : true;
+    const window = typeof input.contextWindow === "number" && input.contextWindow > 0
+        ? deriveEffectiveWindow(input.contextWindow, input.policy)
+        : undefined;
+    const compaction = { enabled };
+    if (window && enabled) {
+        compaction.reserveTokens = window.recommendedReserve;
+        compaction.keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
+    }
+    manager.applyOverrides({ compaction });
+    return {
+        applied: true,
+        enabled,
+        ...(typeof compaction.reserveTokens === "number"
+            ? { reserveTokens: compaction.reserveTokens }
+            : {}),
+        ...(typeof compaction.keepRecentTokens === "number"
+            ? { keepRecentTokens: compaction.keepRecentTokens }
+            : {}),
+        ...(window?.fallback
+            ? { diagnostic: "small-or-invalid-window-fell-back-to-pi-default-reserve" }
+            : {}),
+    };
+}
+export function inMemoryCompactionSettings(policy) {
+    if (policy.mode === "off") {
+        return { enabled: true };
+    }
+    return {
+        enabled: true,
+        keepRecentTokens: DEFAULT_KEEP_RECENT_TOKENS,
+        ...(policy.explicitReserveTokens
+            ? { reserveTokens: policy.explicitReserveTokens }
+            : {}),
+    };
+}