@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-next.1

package/dist/executors/shell-executor.js

@@ -32,11 +32,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";
@@ -870,26 +870,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) {
@@ -912,6 +935,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: "",
@@ -1011,6 +1047,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({
@@ -1021,6 +1058,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", [
@@ -1033,6 +1073,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",
                 "",
@@ -1061,6 +1105,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,
@@ -1183,7 +1230,33 @@ async function executeBackendTestPipeline(input, meta) {
             const pytestTargetsRelative = "reports/backend-test-pytest-targets.txt";
             const pytestTargetsAbsolute = path.join(meta.runDir, pytestTargetsRelative);
             await writeFile(pytestTargetsAbsolute, `${eligibleItemIds.join("\n")}\n`, "utf8");
-            const pytestTargetsArg = `@\"\${HARNESS_DAG_RUN_DIR}/${pytestTargetsRelative}\"`;
+            const pytestLauncherRelative = "reports/backend-test-pytest-launcher.py";
+            const pytestLauncherAbsolute = path.join(meta.runDir, pytestLauncherRelative);
+            await writeFile(pytestLauncherAbsolute, [
+                "import os",
+                "import pathlib",
+                "import sys",
+                "",
+                "sys.path[0] = os.getcwd()",
+                "import pytest",
+                "",
+                "if len(sys.argv) != 3:",
+                "    print('usage: backend-test-pytest-launcher.py <targets-file> <html-file>', file=sys.stderr)",
+                "    raise SystemExit(4)",
+                "targets_path = pathlib.Path(sys.argv[1])",
+                "html_path = pathlib.Path(sys.argv[2])",
+                "try:",
+                "    targets = targets_path.read_text(encoding='utf-8').splitlines()",
+                "except (OSError, UnicodeError) as error:",
+                "    print(f'backend-test targets unreadable: {error}', file=sys.stderr)",
+                "    raise SystemExit(4)",
+                "if not targets or any(not target or target != target.strip() for target in targets):",
+                "    print('backend-test targets must contain non-empty exact pytest node IDs', file=sys.stderr)",
+                "    raise SystemExit(4)",
+                "pytest_args = [*targets, '-v', '-p', 'no:cacheprovider', f'--html={html_path}', '--self-contained-html']",
+                "raise SystemExit(pytest.main(pytest_args))",
+                "",
+            ].join("\n"), "utf8");
             // Split into short bash -c commands (aligned with markdown-environment).
             // A single ultra-long compound command has been observed on Windows to
             // exit 0xC0000142 (STATUS_DLL_INIT_FAILED) in ~40ms with empty stdout/
@@ -1260,10 +1333,11 @@ async function executeBackendTestPipeline(input, meta) {
                 'PYTHON_BIN="$(command -v python || command -v python3 || true)"',
                 'if [ -z "${PYTHON_BIN}" ]; then echo "python/python3 is required for backend-test execution" | tee -a "${DIAG_FILE}" >&2; exit 127; fi',
                 'echo "STEP=pytest-run"',
-                `echo "- pytestCommand: python -m pytest <${eligibleItemIds.length} eligibility-authorized-items> -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
+                `echo "- pytestCommand: controller launcher -> pytest.main(<${eligibleItemIds.length} eligibility-authorized-items>, -v, -p no:cacheprovider, --html=reports/backend-test.html, --self-contained-html)" >> "\${DIAG_FILE}"`,
                 `echo "- eligibleItemCount: ${eligibleItemIds.length}" >> "\${DIAG_FILE}"`,
                 `echo "- excludedItemCount: ${executionReadiness.excludedItems.length}" >> "\${DIAG_FILE}"`,
-                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" -m pytest ${pytestTargetsArg} -v -p no:cacheprovider --html="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" --self-contained-html`,
+                'rm -f "${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-native.html"',
+                `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" "\${HARNESS_DAG_RUN_DIR}/${pytestLauncherRelative}" "\${HARNESS_DAG_RUN_DIR}/${pytestTargetsRelative}" "\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html"`,
                 "STATUS=$?",
                 'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
                 'echo "- pytestExitCode: ${STATUS}" >> "${DIAG_FILE}"',

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/operator/capabilities.js

@@ -51,6 +51,8 @@ const OFFICIAL_ACTION_DESCRIPTIONS = {
     workerSchedulerStatus: "Night-scheduler status overview (agent-worker). Use to check whether overnight jobs are healthy.",
     workerSchedulerLedger: "Night-scheduler harvest ledger (agent-worker). Use to audit what overnight runs produced.",
     workerSchedulerDoctor: "Diagnose night-scheduler health (agent-worker). Use when overnight jobs fail to fire or harvest.",
+    dagResume: "Unpause a run paused at a human decision checkpoint. Orphaned runs (dead runner, liveness=orphaned) are NOT continuable — do not resume them: use dagReconcileRun --action supersede to archive and then advance/rerun the task fresh.",
+    dagReconcileRun: "Reconcile an orphaned run (dead runner, liveness=orphaned). These are NOT continuable: supersede archives the run for a fresh same-task advance/rerun; abandon discards it. resume only unpauses human-decision checkpoints — never for orphaned runs.",
 };
 const officialAction = (action, cli, kind, coverage) => ({
     action,
@@ -817,7 +819,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "BINDING_DRIFT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Issue a session-bound single-use execution receipt after server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
+            description: "Returns SYNCHRONOUSLY (not an operation): it immediately yields a session-bound single-use executionId + receipt, which you then pass to runDag to actually execute. It is a server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1067,6 +1069,12 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "verification entries as label:command strings",
                 },
+                {
+                    name: "approveGate",
+                    type: "string",
+                    required: false,
+                    description: "optional write-set gate approval token `<gate-id>:sha256:<64-hex>` exactly as reported by task status gate.approveCommand; forwards as --approve-gate and executes the approved DAG as this background operation (preferred over a foreground terminal)",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",

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 }
+            : {}),
+    };
+}

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

@@ -0,0 +1,58 @@
+const TRUTHY = new Set(["1", "true", "on"]);
+const FALSY = new Set(["0", "false", "off"]);
+export function parseEnabledFlag(raw, defaultEnabled) {
+    if (raw === undefined || raw.trim() === "") {
+        return { enabled: defaultEnabled };
+    }
+    const value = raw.trim().toLowerCase();
+    if (TRUTHY.has(value))
+        return { enabled: true };
+    if (FALSY.has(value))
+        return { enabled: false };
+    return {
+        enabled: defaultEnabled,
+        diagnostic: `invalid flag ${JSON.stringify(raw)}; clamped to default ${defaultEnabled}`,
+    };
+}
+export function parseContextPressureMode(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return { mode: "safe" };
+    const value = raw.trim().toLowerCase();
+    if (value === "off" || value === "safe" || value === "strict") {
+        return { mode: value };
+    }
+    return {
+        mode: "safe",
+        diagnostic: `invalid HARNESS_CONTEXT_PRESSURE_MODE ${JSON.stringify(raw)}; clamped to safe`,
+    };
+}
+export function parseBoundedNumber(raw, fallback, min, max) {
+    if (raw === undefined || raw.trim() === "") {
+        return { value: fallback };
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+        return {
+            value: fallback,
+            diagnostic: `invalid number ${JSON.stringify(raw)}; clamped to ${fallback}`,
+        };
+    }
+    const clamped = Math.min(max, Math.max(min, parsed));
+    if (clamped !== parsed) {
+        return {
+            value: clamped,
+            diagnostic: `number ${parsed} clamped to [${min}, ${max}] => ${clamped}`,
+        };
+    }
+    return { value: parsed };
+}
+/** Console/DAG sift: default ON; `0|false|off` disables. */
+export function isConsoleSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_CONSOLE_SIFT, true);
+}
+export function isDagSiftEnabled(env = process.env) {
+    return parseEnabledFlag(env.HARNESS_DAG_SIFT, true);
+}
+export function readContextPressureMode(env = process.env) {
+    return parseContextPressureMode(env.HARNESS_CONTEXT_PRESSURE_MODE);
+}

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

@@ -0,0 +1,100 @@
+import { buildOverflowCheckpoint } from "./checkpoint.js";
+import { shouldRewriteAssistantOverflow } from "./overflow.js";
+import { clearRetrieveBypass, compressProviderPayload, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, } from "./sift-bridge.js";
+import { emptyContextPressureCounters, incrementCounter, } from "./telemetry.js";
+export function createCompactionController() {
+    return {
+        proactiveCompaction: false,
+        counters: emptyContextPressureCounters(),
+    };
+}
+export function createContextPressureExtension(options) {
+    const l2 = options.policy.mode !== "off";
+    const l1 = Boolean(options.sift);
+    if (!l2 && !l1)
+        return undefined;
+    return {
+        name: options.name ?? "operator-chat-context-pressure",
+        hidden: true,
+        factory: (api) => {
+            if (l2) {
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (!message || typeof message !== "object")
+                        return undefined;
+                    const rec = message;
+                    if (typeof rec.errorMessage === "string") {
+                        options.controller.lastError = rec.errorMessage;
+                    }
+                    if (rec.role === "assistant") {
+                        clearRetrieveBypassIfPresent(options.sift);
+                    }
+                    const rewritten = shouldRewriteAssistantOverflow(message);
+                    if (!rewritten)
+                        return undefined;
+                    incrementCounter(options.controller.counters, "overflow");
+                    return {
+                        message: {
+                            ...rec,
+                            errorMessage: rewritten,
+                        },
+                    };
+                });
+                api.on("session_before_compact", (event) => {
+                    const reason = event.reason;
+                    if (reason === "overflow") {
+                        incrementCounter(options.controller.counters, "overflow");
+                    }
+                    if (reason === "manual") {
+                        incrementCounter(options.controller.counters, "manual");
+                    }
+                    const useCheckpoint = options.policy.mode === "strict" &&
+                        (reason === "overflow" ||
+                            (reason === "manual" && options.controller.proactiveCompaction));
+                    if (!useCheckpoint)
+                        return undefined;
+                    const checkpoint = buildOverflowCheckpoint({
+                        preparation: event.preparation,
+                        todos: options.controller.todos,
+                        lastError: options.controller.lastError,
+                    });
+                    if (!checkpoint)
+                        return undefined;
+                    return {
+                        compaction: {
+                            summary: checkpoint.summary,
+                            firstKeptEntryId: checkpoint.firstKeptEntryId,
+                            tokensBefore: checkpoint.tokensBefore,
+                        },
+                    };
+                });
+            }
+            if (l1 && options.sift) {
+                const sift = options.sift;
+                api.on("before_provider_request", (event) => {
+                    return compressProviderPayload(sift, event.payload);
+                });
+                api.on("message_end", (event) => {
+                    const message = event.message;
+                    if (message &&
+                        typeof message === "object" &&
+                        message.role === "assistant") {
+                        clearRetrieveBypass(sift);
+                    }
+                    return undefined;
+                });
+                try {
+                    api.registerTool?.(createSiftRetrieveToolDefinition(sift));
+                }
+                catch {
+                    sift.diagnostics.add("register-tool-failed");
+                }
+            }
+        },
+    };
+}
+function clearRetrieveBypassIfPresent(sift) {
+    if (sift)
+        clearRetrieveBypass(sift);
+}
+export { SIFT_RETRIEVE_TOOL_NAME };