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

package/dist/commands/dag-rerun.js

@@ -1,6 +1,13 @@
+import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
+import { executeArtifactRevisionContinuation, planArtifactRevisionContinuation, } from "../workflows/dag/context-transfer/operator-actions.js";
 import { isDagRerunPromptOverrideEnabled } from "../shared/dag-prompt-override.js";
-import { executeDagRerun, planDagRerun, } from "../workflows/dag/rerun-run.js";
+import { workerContinuationAuthorityV1Schema, } from "../shared/context-transfer.js";
+import { openConsoleAppData } from "../infrastructure/console/app-data.js";
+import { buildArtifactOverrideSet, consumeArtifactRevision, readArtifactRevision, readArtifactRevisionCandidate, acquireArtifactRevisionLease, releaseArtifactRevisionLease, EXECUTE_REVISION_LEASE_TTL_MS, } from "../infrastructure/console/artifact-revision-store.js";
+import { buildArtifactBindingGraph } from "../workflows/dag/artifact-bindings.js";
+import { locateDagRun, readDagRunSpec } from "../workflows/dag/lifecycle.js";
+import { executeDagRerun, planDagRerun, readOperatorRequestReplay, } from "../workflows/dag/rerun-run.js";
 export function parseDagRerunArgs(args) {
     if (args.length === 0) {
         throw new Error("usage: dag rerun --run-id <id> --from-node <node-id> --plan [--json] | dag rerun --run-id <id> --from-node <node-id> --plan-hash <hash> --request-id <key> --reason <text> [--json]");
@@ -111,6 +118,10 @@ async function loadPromptOverrides(specs, mode) {
     return overrides;
 }
 export async function runDagRerun(repoRoot, rawArgs) {
+    if (rawArgs.some((arg) => arg === "--artifact-revision" || arg.startsWith("--artifact-revision="))) {
+        await runArtifactRevisionRerun(repoRoot, rawArgs);
+        return;
+    }
     const parsed = parseDagRerunArgs(rawArgs);
     let promptOverrides;
     const hasOverrides = parsed.promptOverrideSpecs.length > 0 ||
@@ -163,3 +174,197 @@ export async function runDagRerun(repoRoot, rawArgs) {
         }
     }
 }
+function readFlag(args, name) {
+    const exact = args.indexOf(name);
+    if (exact >= 0)
+        return args[exact + 1];
+    const prefix = `${name}=`;
+    return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+function parseWorkerContinuationAuthority(raw) {
+    if (raw === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("dag rerun --worker-continuation must be valid JSON");
+    }
+    const result = workerContinuationAuthorityV1Schema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`dag rerun --worker-continuation is invalid: ${result.error.issues[0]?.message ?? "schema mismatch"}`);
+    }
+    return result.data;
+}
+function executeLeaseHolder(requestId) {
+    // The request id identifies the idempotency envelope, not a live process.
+    // A unique invocation holder prevents two concurrent direct CLI invocations
+    // with the same request id from treating each other as a lease renewal.
+    return `cli-execute:${requestId}:${randomBytes(12).toString("hex")}`;
+}
+/**
+ * Hold the staging lease across candidate read + continuation execution so a
+ * concurrent discard/second execute fails with LEASE_HELD and a crashed
+ * process leaves a stale, TTL-takeover-able lease instead of silent races.
+ * The acquire/renew here also refreshes the sliding window before the long
+ * child run starts.
+ */
+async function withExecuteRevisionLease(appData, requestId, revisionId, operation) {
+    const holder = executeLeaseHolder(requestId);
+    await acquireArtifactRevisionLease({
+        appData,
+        revisionId,
+        holder,
+        ttlMs: EXECUTE_REVISION_LEASE_TTL_MS,
+    });
+    try {
+        return await operation(holder);
+    }
+    finally {
+        await releaseArtifactRevisionLease({
+            appData,
+            revisionId,
+            holder,
+        }).catch(() => { });
+    }
+}
+export async function runArtifactRevisionRerunCore(repoRoot, rawArgs, cliOptions) {
+    const allowed = new Set([
+        "--run-id",
+        "--artifact-revision",
+        "--plan-hash",
+        "--request-id",
+        "--reason",
+        "--worker-continuation",
+    ]);
+    for (let index = 0; index < rawArgs.length; index += 1) {
+        const arg = rawArgs[index];
+        if (arg === "--plan" || arg === "--json")
+            continue;
+        const name = arg.split("=", 1)[0];
+        if (!allowed.has(name))
+            throw new Error(`unknown artifact revision rerun flag: ${arg}`);
+        if (!arg.includes("="))
+            index += 1;
+    }
+    const parentRunId = readFlag(rawArgs, "--run-id")?.trim();
+    const revisionId = readFlag(rawArgs, "--artifact-revision")?.trim();
+    const planOnly = rawArgs.includes("--plan");
+    if (!parentRunId || !revisionId) {
+        throw new Error("dag rerun artifact revision requires --run-id and --artifact-revision");
+    }
+    const appData = openConsoleAppData({
+        repoRoot,
+        ...(cliOptions?.appDataRoot ? { appDataRoot: cliOptions.appDataRoot } : {}),
+    });
+    const planHash = readFlag(rawArgs, "--plan-hash")?.trim();
+    const requestId = readFlag(rawArgs, "--request-id")?.trim();
+    const reason = readFlag(rawArgs, "--reason")?.trim();
+    const workerContinuation = parseWorkerContinuationAuthority(readFlag(rawArgs, "--worker-continuation"));
+    if (!planOnly && (!planHash || !requestId || !reason)) {
+        throw new Error("dag rerun artifact revision execute requires --plan-hash, --request-id, and --reason");
+    }
+    if (!planOnly) {
+        // Replay-first (B4): a prior execute may have consumed the revision and
+        // the staging record may already have been reconciled away. The persisted
+        // operator request is the authoritative idempotent result and must be
+        // honored before any dependency on the revision metadata. A replay that
+        // does not match the requested parent/planHash is a reuse conflict, not a
+        // valid idempotent answer (SF2).
+        const replay = await readOperatorRequestReplay(repoRoot, requestId, {
+            parentRunId,
+            planHash,
+        });
+        if (replay) {
+            return {
+                payload: replay,
+                exitCode: replay.ok
+                    ? 0
+                    : replay.errorCode === "RERUN_PLAN_DRIFT"
+                        ? 3
+                        : replay.errorCode === "INELIGIBLE"
+                            ? 2
+                            : 1,
+            };
+        }
+    }
+    const revision = await readArtifactRevision(appData, revisionId);
+    if (!revision || revision.parent.runId !== parentRunId) {
+        throw new Error("ARTIFACT_REVISION_EXPIRED");
+    }
+    const located = await locateDagRun(repoRoot, parentRunId);
+    if (!located)
+        throw new Error(`dag run not found: ${parentRunId}`);
+    const declaration = buildArtifactBindingGraph(await readDagRunSpec(located.runDir)).artifacts.find((item) => item.producerNodeId === revision.parent.nodeId &&
+        item.path === revision.parent.artifactPath);
+    if (!declaration)
+        throw new Error("ARTIFACT_BINDING_UNAVAILABLE");
+    const artifactOverrides = buildArtifactOverrideSet(revision);
+    if (planOnly) {
+        if (planHash || requestId || reason) {
+            throw new Error("dag rerun --plan cannot be combined with execute flags");
+        }
+        const plan = await planArtifactRevisionContinuation({
+            cwd: repoRoot,
+            parentRunId,
+            artifactId: declaration.artifactId,
+            artifactOverrides,
+            stagingRevisionSha256: revision.candidate.sha256,
+            ...(workerContinuation
+                ? { workerContinuationAuthority: workerContinuation }
+                : {}),
+        });
+        return { payload: { ok: plan.eligible, plan }, exitCode: plan.eligible ? 0 : 2 };
+    }
+    if (revision.state === "consumed") {
+        // Replay was not found above, so this is a crashed consume without a
+        // persisted result — refuse rather than re-execute a consumed revision.
+        throw new Error("ARTIFACT_REVISION_EXPIRED: revision already consumed and no operator replay exists for this request");
+    }
+    const result = await withExecuteRevisionLease(appData, requestId, revision.revisionId, async (leaseHolder) => {
+        const candidateBytes = await readArtifactRevisionCandidate({ appData, revision });
+        return executeArtifactRevisionContinuation({
+            cwd: repoRoot,
+            parentRunId,
+            artifactId: declaration.artifactId,
+            artifactOverrides,
+            stagingRevisionSha256: revision.candidate.sha256,
+            candidateBytes,
+            planHash: planHash,
+            requestId: requestId,
+            reason: reason,
+            ...(workerContinuation
+                ? { workerContinuationAuthority: workerContinuation }
+                : {}),
+            consumeRevision: async ({ revisionId: consumedId, expectedSha256 }) => {
+                await consumeArtifactRevision({
+                    appData,
+                    revisionId: consumedId,
+                    expectedSha256,
+                    holder: leaseHolder,
+                });
+            },
+        });
+    });
+    return {
+        payload: result,
+        exitCode: result.ok
+            ? 0
+            : result.errorCode === "RERUN_PLAN_DRIFT"
+                ? 3
+                : result.errorCode === "INELIGIBLE"
+                    ? 2
+                    : 1,
+    };
+}
+async function runArtifactRevisionRerun(repoRoot, rawArgs) {
+    const { payload, exitCode } = await runArtifactRevisionRerunCore(repoRoot, rawArgs);
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    if (exitCode !== 0) {
+        const failure = payload;
+        const message = failure.message ?? failure.errorCode ?? `artifact rerun failed with exit ${exitCode}`;
+        process.stderr.write(`${message}\n`);
+        process.exitCode = exitCode;
+    }
+}

package/dist/commands/init-model-catalog.js

@@ -31,8 +31,28 @@ function sanitizeInputKinds(value) {
         .sort();
     return entries.length > 0 ? entries : undefined;
 }
+const AICODER_CAPABILITY_RANK = {
+    "aicoder-default": 1,
+    "aicoder-plus": 2,
+    "aicoder-pro": 3,
+    "aicoder-max": 4,
+};
+function relativeCapabilityForModelId(provider, modelId) {
+    if (provider !== "wizard-local")
+        return undefined;
+    const rank = AICODER_CAPABILITY_RANK[modelId];
+    if (!rank)
+        return undefined;
+    return {
+        family: "aicoder",
+        rank,
+        scale: 4,
+        order: "weakest-to-strongest",
+    };
+}
 function createCatalogEntry(input) {
     const piCompatible = input.source === "pi";
+    const relativeCapability = relativeCapabilityForModelId(input.provider, input.modelId);
     return {
         reference: `${input.provider}/${input.modelId}`,
         provider: input.provider,
@@ -42,6 +62,7 @@ function createCatalogEntry(input) {
         credentialReady: input.credentialReady,
         piCompatible,
         eligibleForHarness: piCompatible && input.credentialReady === true && input.tools !== false,
+        ...(relativeCapability ? { relativeCapability } : {}),
         ...(compactRecord({
             reasoning: input.reasoning,
             tools: input.tools,
@@ -448,6 +469,7 @@ export async function discoverInitModelCatalog(options) {
             rules: [
                 "Choose only models with eligibleForHarness=true; OpenCode-only entries are context, not proof of Pi executor compatibility.",
                 "Use target-project evidence plus model capabilities, cost, context window, and credential readiness; tiers may intentionally share a model.",
+                "When relativeCapability is present, compare only entries from the same family and treat larger rank values as stronger; it is a relative capability hint, not a mandatory LOW/MED/HIGH assignment.",
                 "Preserve an existing complete usable matrix unless it is unavailable or the user asked to reselect it.",
                 "Ask the user only for a material unresolved credential, cost, compliance, or availability decision.",
             ],

package/dist/commands/task-advance.js

@@ -13,7 +13,7 @@ const USAGE = `usage:
     [--feature-id <id>]
     [--allowed-path <glob>]...
     [--forbidden-path <glob>]...
-    [--verify <label:command>]...
+    [--verify <label:command>]...   # e.g. --verify "typecheck:npx tsc --noEmit" (label BEFORE the colon)
     [--verify-timeout <label:timeoutMs>]...
     [--backend-test <json>]
     [--accept-recommendations <digest>]
@@ -31,6 +31,7 @@ const USAGE = `usage:
     [--progress-interval-ms <ms>]
     [--dry-run]
     [--json]`;
+export { USAGE as TASK_ADVANCE_USAGE };
 function pushList(target, value) {
     const list = target ?? [];
     list.push(value);
@@ -232,6 +233,26 @@ export function parseTaskAdvanceArgs(args) {
     }
     return { taskId, options };
 }
+const FOREGROUND_DAG_WARNING = [
+    "[task advance] --approve-gate will execute the whole DAG in the FOREGROUND:",
+    "  this terminal must stay open until every node finishes (writer nodes can run 10-60+ min).",
+    "  Killing it mid-run (timeout / Ctrl-C / closed terminal) leaves an orphaned run that",
+    "  only `dag reconcile-run --action supersede|abandon` can close.",
+    "  Prefer background holders instead:",
+    "    - Console: prepareDagExecution -> runDag (operation-held)",
+    "    - CLI:     nohup loop-agent task advance <task-id> --approve-gate <token> ... &",
+].join("\n");
+/**
+ * Operator guardrail (dogfood 2026-08-29): warn a human sitting on a TTY that
+ * `--approve-gate` runs the full DAG in the foreground before the process
+ * parks on node execution. Piped/non-TTY invocations (Console operations,
+ * scripts, --json pipelines) stay silent so machine paths are unaffected.
+ */
+export function warnForegroundDagExecution(options, stream = process.stderr) {
+    if (options.quiet || stream.isTTY !== true)
+        return;
+    stream.write(`${FOREGROUND_DAG_WARNING}\n`);
+}
 function mapOutcome(result) {
     if (result.blockers.length > 0) {
         const code = result.blockers[0]?.code ?? "";
@@ -351,6 +372,7 @@ export async function runTaskAdvance(repoRoot, args) {
         // ONLY for the approve-gate execution path and disposed on every exit;
         // its timer starts only after onRunStart (double guard, no stray timer).
         if (options.approveGate && !options.dryRun && !options.quiet) {
+            warnForegroundDagExecution(options);
             progress = createRunDagProgressObserver({
                 intervalMs: options.progressIntervalMs,
             });

package/dist/commands/task-source-prepare.js

@@ -32,6 +32,7 @@ const USAGE = `usage:
     [--dry-run | --apply]
     [--force-overwrite-source]
     [--json]`;
+export { USAGE as TASK_SOURCE_PREPARE_USAGE };
 function pushList(target, value) {
     const list = target ?? [];
     list.push(value);
@@ -386,6 +387,10 @@ function printHuman(result) {
     console.log(lines.join("\n"));
 }
 export async function runTaskSourcePrepare(repoRoot, args) {
+    // CLI chain routing (task -> source -> prepare) folds the leaf name into
+    // rest[0]; strip it so `loop-agent task source prepare <id> ...` works.
+    if (args[0] === "prepare")
+        args = args.slice(1);
     if (args.includes("--help") || args.includes("-h")) {
         console.log(USAGE);
         process.exitCode = 0;

package/dist/commands/task-status.js

@@ -3,6 +3,7 @@ import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOp
 const COMMAND = "task status";
 const USAGE = `usage:
   task status <task-id> [--json|--markdown] [--details]`;
+export { USAGE as TASK_STATUS_USAGE };
 export function parseTaskStatusArgs(args) {
     const options = {};
     const positional = [];

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

@@ -13,8 +13,9 @@ import { captureWorkspaceWriteSnapshot, diffWorkspaceWriteSnapshots, } from "./w
 import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
-import { frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
+import { frontendTestLayoutFromSpec } from "../workflows/dag/frontend-test-layout.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
+import { writeEffectiveContextReceipt } from "../workflows/dag/context-receipt.js";
 /**
  * Writer classification for a length-stopped thinking-only attempt: the model
  * exhausted its output budget thinking but never issued a write/edit tool call
@@ -516,7 +517,11 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let playwrightToolContext;
     if (allowsPlaywrightCli && !isWriteTask) {
         return {
-            ok: false, stdout: "", stderr: "pi command capability requires an explicit bounded write tool profile", failureCategory: "tool-policy", durationMs: Date.now() - started,
+            ok: false,
+            stdout: "",
+            stderr: "pi command capability requires an explicit bounded write tool profile",
+            failureCategory: "tool-policy",
+            durationMs: Date.now() - started,
         };
     }
     const strictReadSet = (input.task.readSet?.length ?? 0) > 0;
@@ -642,14 +647,34 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         const piExtensionPaths = piExtensionsResolution && resolvePiBackend() !== "cli-only"
             ? piExtensionsResolution.resolved.flatMap((entry) => entry.entryPaths)
             : undefined;
+        const modelConfig = resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined);
+        const toolNames = resolveDagPiToolNames(input.task);
+        const userMessage = buildDagPiUserMessage(input.task, persona, step);
+        await writeEffectiveContextReceipt({
+            runDir: meta.runDir,
+            runId: meta.runId,
+            nodeId: input.task.id,
+            attempt,
+            task: input.task,
+            spec: meta.spec,
+            repoRoot: input.cwd,
+            systemPrompt: input.prompt,
+            userMessage,
+            resolvedModel: `${modelConfig.provider}/${modelConfig.model}`,
+            resolvedSkills: input.resolvedSkills ?? [],
+            resolvedExtensions: piExtensionsResolution && resolvePiBackend() !== "cli-only"
+                ? piExtensionsResolution.resolved.map((entry) => entry.id)
+                : [],
+            activeTools: toolNames,
+        });
         result = await piStepFn({
             attachedFiles: [],
-            modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
+            modelConfig,
             prompt: input.prompt,
             repoRoot: input.cwd,
             step,
-            toolNames: resolveDagPiToolNames(input.task),
-            userMessage: buildDagPiUserMessage(input.task, persona, step),
+            toolNames,
+            userMessage,
             sessionEventsPath: path.join(meta.runDir, input.task.id, "session-events.jsonl"),
             // Absolute max wall clock from adaptive liveness policy (defaults to 4h).
             timeoutMs: input.timeoutMs,
@@ -927,8 +952,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         });
     }
     let completenessFailure;
-    if (writeGuardOk &&
-        isBackendTestCompletenessRetryCandidate(input.task)) {
+    if (writeGuardOk && isBackendTestCompletenessRetryCandidate(input.task)) {
         try {
             const writerRole = backendTestWriterProgressRoleForTask(input.task.id);
             const backendLayout = resolveBackendTestLayout(meta.spec.backendTestLayout
@@ -941,7 +965,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const progress = isBackendTestShardChildTask(input.task)
                 ? await assessBackendTestShardChildCompleteness({
                     workspaceRoot: input.cwd,
-                    role: writerRole === "pytest-generate" ? "pytest-generate" : "md-generate",
+                    role: writerRole === "pytest-generate"
+                        ? "pytest-generate"
+                        : "md-generate",
                     writeSet: input.task.writeSet ?? [],
                 })
                 : isBackendTestMdPlanTask(input.task)
@@ -987,7 +1013,10 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             };
         }
     }
-    if (mapped.ok && writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
+    if (mapped.ok &&
+        writeGuardOk &&
+        !writerOutcomeViolation &&
+        !completenessFailure) {
         return mapped;
     }
     const writerThinkingExhausted = isWriterThinkingExhausted(result, mapped, changeManifestChangedFiles);
@@ -1393,9 +1422,7 @@ async function persistWriterChangeManifest(input) {
         ...(input.approvalSourceNodeId
             ? { approvalSourceNodeId: input.approvalSourceNodeId }
             : {}),
-        ...(input.approvalDigest
-            ? { approvalDigest: input.approvalDigest }
-            : {}),
+        ...(input.approvalDigest ? { approvalDigest: input.approvalDigest } : {}),
         changedFiles: input.changedFiles,
         beforeStatusSha256: createHash("sha256")
             .update(input.beforeStatus)

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;
 /**
@@ -212,18 +215,43 @@ async function createSdkSession(sdk, input, shared) {
     const model = input.provider && input.model
         ? await resolveModel(modelRuntime, input.provider, input.model)
         : undefined;
+    if (input.provider && input.model && !model) {
+        throw new Error(`pi SDK model unavailable: ${input.provider}/${input.model}; refusing to fall back to the session default`);
+    }
     // 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 +261,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 +276,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) {