@hicaru/pi-rlm 0.3.16 → 0.3.17

package/src/index.ts

@@ -21,15 +21,18 @@ import { SANDBOX_WATCHDOG_HEARTBEAT_MS } from "./sandbox/sandbox.ts";
 import { SandboxManager } from "./sandbox/sandbox-manager.ts";
 import { buildSessionGates, type SubcallGates } from "./util/concurrency.ts";
 import { BackgroundTasks } from "./tool/background-tasks.ts";
-import { MemoryStore } from "./core/memory.ts";
-import { modelComplete } from "./bridge/model.ts";
-import { retryPolicy } from "./util/retry.ts";
 import { resolve } from "node:path";
 import { resolveSource } from "./context/resolve.ts";
 import { formatContextListing } from "./context/listing.ts";
 import { extractEditPaths, readDiskFile } from "./context/refresh.ts";
 import type { AddContextHandlerBundle } from "./bridge/add-context.ts";
 import { buildNativeSystemPrompt } from "./prompts/native.ts";
+import { SkillStore, notesFromRunState, xiQuery } from "./config/skillstate.ts";
+import { buildRootDigestCompaction } from "./core/root-digest.ts";
+import { RootStateTracker } from "./core/root-state.ts";
+import { elideStalePayloads, spliceSigmaSnapshot } from "./core/root-context.ts";
+import { agentMessageText, firstLine, textContentOf } from "./text/agent-text.ts";
+import { findStatePatches } from "./text/parsing.ts";
 import { capToolResultText } from "./mode/native-guards.ts";
 import {
   isSubagentChildBypass,
@@ -69,21 +72,10 @@ export default function rlmExtension(pi: ExtensionAPI): void {
 
   // Init synchronously with defaults — ensures commands/tools/handlers register before session_start
   const config = mergeConfig({});
-  // v5 durable memory: one store per session under <cwd>/.rlm/memory (L1 replay + L2 notes).
-  // NOTE (audit M4): this store IS shared by both composition roots, but the TaskLedger is
-  // NOT — the native repl() session and each headless rlm run each keep their own blackboard
-  // (v5 parity: per-run ledger). Claims/coalescing reset at that boundary, by design.
-  // The consolidation LLM + real workspace root are attached in session_start (setLlm/setRoot).
-  const memory = new MemoryStore(
-    process.cwd(),
-    {
-      dir: config.memoryDir ?? undefined,
-      injectNoteTokens: config.injectNoteTokens,
-      evolveEvery: config.evolveEvery,
-    },
-    config.enableMemory,
-  );
-  const controller = new RlmController(config, memory);
+  const controller = new RlmController(config);
+  // Root Σ WS-4: engine-finalize Σ flows into the root tracker (assigned once; buildEngine
+  // reads it per run, so /rlm-config and session resets never stale this wire).
+  controller.onRunState = (state) => { rootTracker?.absorbEngineState(state); };
   let onSandboxDiscardExtra: (() => void) | undefined;
   const sandboxManager = new SandboxManager({
     execTimeoutS: config.execTimeoutS,
@@ -116,6 +108,16 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     hideWhenEmpty: true,
   });
   let treePanelInstalled = false;
+  /** SKILL.state (Workstream B): session store — hydrated at session_start, flushed at shutdown. */
+  let skillStore: SkillStore | undefined;
+  /** Root Σ (WS-3/4): the native session's digest-level Σ_t — runtime-derived (tool outcomes,
+   *  engine mirrors, prompts); lazily born on the first prompt, harvested + dropped at shutdown. */
+  let rootTracker: RootStateTracker | undefined;
+  // Root Σ WS-5.1 telemetry — journal counters (trace lines only; no TUI surface by design).
+  let xiCompositions = 0;
+  let rootDigests = 0;
+  let elidedMessages = 0;
+  let sigmaSplices = 0;
   // A detached child works in its OWN sandbox, so this one sees no frames and its request
   // watchdog would fire mid-await and SIGKILL a healthy worker, taking the REPL namespace
   // with it. Keep it alive while detached work is genuinely in flight.
@@ -157,17 +159,25 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     await seedPromise;
   };
 
+  /** Ξ (Workstream C): BM25 slice of the SkillState store for a query; undefined when off. */
+  const composeSkillBlock = (query: string): string | undefined => {
+    const cfg = controller.config;
+    if (!cfg.enableSkillState || skillStore === undefined) return undefined;
+    const block = skillStore.blockFor(query, cfg.skillStateMaxTokens);
+    return block === "" ? undefined : block;
+  };
+
   // ── Message renderers ──
   // Markdown themes are derived from the injected `theme`, never pi's module-global
   // `getMarkdownTheme()` — under jiti that global can be undefined inside a plugin.
   pi.registerMessageRenderer("rlm-answer", (message, _options, theme) =>
-    new Markdown(String(message.content ?? ""), 1, 0, markdownTheme(theme)),
+    new Markdown(textContentOf(message.content), 1, 0, markdownTheme(theme)),
   );
   pi.registerMessageRenderer("rlm-question", (message, _options, theme) =>
-    new Markdown(`**RLM question**\n\n${String(message.content ?? "")}`, 1, 0, markdownTheme(theme)),
+    new Markdown(`**RLM question**\n\n${textContentOf(message.content)}`, 1, 0, markdownTheme(theme)),
   );
   pi.registerMessageRenderer("rlm-intro", (message, _options, theme) =>
-    new Markdown(String(message.content ?? ""), 1, 0, markdownTheme(theme)),
+    new Markdown(textContentOf(message.content), 1, 0, markdownTheme(theme)),
   );
 
   // ── CLI flag: `pi --rlm` / `pi --rlm=false` overrides the persisted mode for this run ──
@@ -194,11 +204,17 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     controller.savedLlmRef = persisted.llm ?? undefined;
     controller.savedRlmRef = persisted.rlm ?? undefined;
 
+    // SKILL.state (Workstream B): hydrate the cross-session note store (fail-soft).
+    skillStore = controller.config.enableSkillState
+      ? await SkillStore.hydrate(controller.config.skillStateNotesPerProject)
+      : undefined;
+    controller.skillStore = skillStore;
+
     // An explicit --rlm flag wins over the persisted setting for this session.
     const flag = pi.getFlag("rlm");
     if (typeof flag === "boolean") controller.setConfig(Object.freeze({ ...controller.config, enabled: flag }));
 
-    // Reload the catalog before the worker-model pick below reads it. Newer pi builds make
+    // Reload the catalog before the worker pick below reads it. Newer pi builds make
     // `getAvailable()` an async-populated snapshot that starts empty, and picking from an empty
     // catalog silently falls back to the root model. Called with no arguments and awaited so it
     // is valid whether `refresh` returns void (current) or a promise (newer); fail-soft, because
@@ -253,17 +269,6 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const llmModel = controller.llmModel ?? cheapestModel(ctx.modelRegistry) ?? ctx.model;
     const model = ctx.model;
     if (llmModel && model) {
-      // Consolidation runs on the cheap worker model through the single completion entry point;
-      // the workspace root is only known once the session starts.
-      const consolidateModel = llmModel;
-      memory.setLlm((prompt) =>
-        modelComplete([{ role: "user", content: prompt }], {
-          model: consolidateModel,
-          registry: ctx.modelRegistry,
-          retry: retryPolicy(controller.config),
-        })
-          .then((r) => r.text));
-      memory.setRoot(ctx.cwd ?? process.cwd());
       // v5 provider caps (audit C1/C6): ONE resolver shared by both composition roots — the
       // repl() tool and RlmController.start admit through the same pool, each gate capped
       // against the model that actually runs on it (leaves = worker, children = smart).
@@ -294,7 +299,9 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       try {
         pi.registerTool(createReplTool({
           sandboxManager,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- pi-ai registry types Model<any>; runtime models conform to Model<Api>
           model,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- see above
           llmModel,
           getModel: () => controller.resolveModels(ctx)?.model,
           getLlmModel: () => controller.resolveModels(ctx)?.llm,
@@ -304,7 +311,9 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           resolveGates: resolveSessionGates,
           background,
           runRegistry,
-          memory,
+          skillStore,
+          onRunState: (state) => { rootTracker?.absorbEngineState(state); },
+          getSkillBlock: composeSkillBlock,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
           registerContextBundle: (bundle) => {
             contextBundleRef = bundle;
@@ -350,10 +359,83 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       activeToolNames: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : undefined,
     });
 
+  /** Root Σ WS-3 gate: config flag AND the bench A/B toggle (RLM_BENCH_NO_ROOTCONTEXT=1 skips). */
+  const rootContextActive = (): boolean =>
+    controller.config.enableRootContextTransform && process.env.RLM_BENCH_NO_ROOTCONTEXT !== "1";
+
   // ── System prompt: native RLM mode addendum (only when the trade holds) ──
   pi.on("before_agent_start", async (event) => {
     if (!nativeTradeHolds()) return;
-    return { systemPrompt: event.systemPrompt + "\n\n" + buildNativeSystemPrompt() };
+    // Root Σ: lazy tracker birth on the session's first prompt (the task IS that prompt).
+    rootTracker ??= RootStateTracker.fresh(event.prompt, controller.config.runStateRetryMax);
+    // Ξ (Workstream C / Root Σ WS-1): the block is PER-PROMPT text — BM25 ranks the store
+    // against the live user prompt (mid-session harvests surface immediately), falling back
+    // to the static slice when the prompt is empty. Concatenated here, so NATIVE_PROMPT_STATIC
+    // (the module-load snapshot) and its budget math stay untouched.
+    const xi = composeSkillBlock(xiQuery(event.prompt, event.systemPrompt.slice(0, 2_000)));
+    if (xi !== undefined) {
+      xiCompositions += 1;
+      if (traceEnabled) trace("root-xi.compose", { total: xiCompositions, chars: xi.length });
+    }
+    const xiPart = xi === undefined ? "" : `${xi}\n\n`;
+    // Root Σ WS-4: the user's latest ask IS the next step by definition; feed the tracker
+    // before the turn so the Σ snapshot in this turn's context carries it.
+    rootTracker?.setNextStep(event.prompt);
+    // Root Σ WS-4.2 (enableRootStateFences): a rejected ΔΣ_t from the previous turn surfaces
+    // as an observation message — the same error-as-observation retry ladder engine runs use.
+    const observation = rootTracker?.takePendingObservation();
+    const message = observation === undefined
+      ? undefined
+      : { customType: "rlm-sigma-observation", content: observation, display: false, details: undefined };
+    return {
+      ...(message === undefined ? {} : { message }),
+      systemPrompt: event.systemPrompt + "\n\n" + xiPart + buildNativeSystemPrompt(),
+    };
+  });
+
+  // Root Σ WS-4.2 (default OFF): capture model-proposed ΔΣ_t fences from finalized assistant
+  // replies and run them through the ONE patch validator (run-state.ts applyPatch).
+  pi.on("message_end", async (event) => {
+    const tracker = rootTracker;
+    if (tracker === undefined || !controller.config.enableRootStateFences) return;
+    if (event.message.role !== "assistant") return;
+    const text = agentMessageText(event.message);
+    if (text === "") return;
+    tracker.applyFences(findStatePatches(text));
+  });
+
+  // ── Root Σ WS-2: deterministic root compaction (no summary LLM call) ──
+  pi.on("session_before_compact", async (event) => {
+    if (!controller.config.enableRootDigestCompaction) return undefined;
+    if (!nativeTradeHolds() && !controller.enabled) return undefined;
+    try {
+      const result = buildRootDigestCompaction({
+        preparation: event.preparation,
+        branchEntries: event.branchEntries,
+        config: controller.config,
+        store: skillStore,
+      });
+      if (result !== undefined) {
+        rootDigests += 1;
+        if (traceEnabled) {
+          // V1 soak probe: host-consumed tokensBefore vs our recomputation over the same span.
+          trace("root-digest.built", {
+            count: rootDigests,
+            chars: result.compaction.summary.length,
+            tokensBefore: result.compaction.tokensBefore,
+            tokensBeforeRecomputed: result.tokensBeforeRecomputed,
+          });
+        }
+      }
+      // SessionBeforeCompactResult SHAPE: the host consumes `result.compaction` — return the
+      // WRAPPER, never the bare CompactionResult (a bare one reads as `compaction: undefined`
+      // host-side and silently falls back to the LLM summarizer).
+      return result === undefined ? undefined : { compaction: result.compaction };
+    } catch (err) {
+      // Fail-soft by contract (packages/agent/src/types.ts:191): Pi falls back to its summarizer.
+      if (traceEnabled) trace("root-digest.fail", { error: errorMessage(err) });
+      return undefined;
+    }
   });
 
   // ── Context injection: listing of whatever is currently loaded ──
@@ -367,6 +449,29 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     );
     if (!nativeTradeHolds()) return { messages: filtered };
 
+    // Root Σ WS-3: per-call A_t on the clone Pi hands us (runner.ts structuredClone — the last
+    // returned array wins; the disk transcript is untouched). Elide stale payloads (§5.3),
+    // then splice exactly one fresh Σ snapshot. Fail-soft: a throw here must never break a turn.
+    if (rootContextActive()) {
+      try {
+        const elided = elideStalePayloads(filtered, {
+          keepTurns: controller.config.rootContextKeepTurns,
+          elideChars: controller.config.rootContextElideChars,
+        });
+        elidedMessages += elided;
+        const tracker = rootTracker;
+        if (controller.config.rootContextSnapshot && tracker !== undefined && !tracker.isEmpty) {
+          spliceSigmaSnapshot(filtered, tracker.snapshot(), tracker.rectifyHint());
+          sigmaSplices += 1;
+        }
+        if (traceEnabled && (elided > 0 || sigmaSplices > 0)) {
+          trace("root-context.transform", { elided, total: elidedMessages, splices: sigmaSplices });
+        }
+      } catch (err) {
+        if (traceEnabled) trace("root-context.fail", { error: errorMessage(err) });
+      }
+    }
+
     type PiMessage = (typeof filtered)[number];
 
     const payload = sandboxManager.contextPayload;
@@ -398,17 +503,29 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   const MUTATING_FILE_TOOLS = Object.freeze(new Set(["edit", "write"]));
 
   pi.on("tool_result", async (event, ctx) => {
+    // Root Σ WS-4: the tracker learns the session's shape from outcomes — deterministic, zero
+    // model cooperation; fresh results always outrank Σ (paper §5.3 observation override).
+    const tracker = rootTracker;
+    if (tracker !== undefined) {
+      tracker.observeToolResult(
+        event.toolName,
+        event.isError,
+        event.isError ? firstLine(textContentOf(event.content)) : "",
+      );
+    }
+
     // ── Keep RLM context fresh after native file mutations ──
     if (
       nativeTradeHolds()
       && MUTATING_FILE_TOOLS.has(event.toolName)
-      && event.isError !== true
+      && !event.isError
     ) {
       const cwd = resolve(ctx?.cwd ?? process.cwd());
       const paths = extractEditPaths(event.input);
       for (const p of paths) {
         const body = await readDiskFile(p, cwd);
         if (body === null) continue;
+        rootTracker?.noteFact(`edited ${p}`); // WS-4: the tracker learns the session's file shape
         try {
           await sandboxManager.refreshFileFromDisk(p, body, cwd);
           // Listing must re-inject if we rewrote payload identity
@@ -435,6 +552,18 @@ export default function rlmExtension(pi: ExtensionAPI): void {
 
   // ── Session shutdown: cleanup ──
   pi.on("session_shutdown", async () => {
+    // Root Σ WS-4 harvest symmetry: the root tracker teaches the store exactly like engine
+    // runs — the ONE notesFromRunState path — then the existing flush persists everything.
+    const tracker = rootTracker;
+    if (skillStore !== undefined && tracker !== undefined && tracker.dirty && controller.config.enableSkillState) {
+      try {
+        skillStore.merge(notesFromRunState(tracker.snapshot()));
+        if (traceEnabled) trace("root-harvest.merged", { notes: tracker.snapshot().verifiedFacts.length });
+      } catch (err) {
+        if (traceEnabled) trace("root-harvest.fail", { error: errorMessage(err) });
+      }
+    }
+    await skillStore?.flush(); // SKILL.state (Workstream B): persist distilled notes
     controller.abort();
     clearInterval(watchdogHeartbeat);
     background.dispose();
@@ -444,6 +573,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     contextBundleRef = undefined;
     listingPayloadRef = undefined;
     listingInjected = false;
+    skillStore = undefined;
+    rootTracker = undefined;
     sandboxManager.contextPayload = [];
   });
 }

package/src/mode/llm-model.ts

@@ -9,7 +9,7 @@
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
-import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
 
 /** $/Mtok, input-weighted 3:1 — a sub-call sends a file body and gets back a sentence. */
 function priceOf(model: Model<Api>): number {
@@ -48,7 +48,19 @@ export function cheapestModel(registry: ModelRegistry): Model<Api> | undefined {
   for (let i = 0; i < models.length; i++) {
     const model = models[i];
     if (model === undefined) continue;
+    // Sentinel negative cost (openrouter/auto reports −1e6) = unpriceable router. priceOf()
+    // would crown it "cheapest" (−4M) — skip; fail closed on unknown prices.
+    if ((model.cost?.input ?? 0) < 0 || (model.cost?.output ?? 0) < 0) continue;
     if (best === undefined || compareLlm(model, best) < 0) best = model;
   }
   return best;
 }
+
+/** Newer Pi hosts expose session-scoped models; 0.79 peers do not — duck-type safely.
+ *  DRY: the ONE reflection probe — shared by /rlm-llm and /rlm-rlm. */
+export function sessionScopedModels(
+  ctx: ExtensionContext,
+): readonly { readonly model: Model<Api> }[] | undefined {
+  const scoped: unknown = Reflect.get(ctx, "scopedModels");
+  return Array.isArray(scoped) ? scoped as readonly { readonly model: Model<Api> }[] : undefined;
+}

package/src/mode/native-guards.ts

@@ -40,12 +40,6 @@ export function isFileReadingCommand(command: string): boolean {
   return statementHeads(command).some((h) => READER_COMMANDS.has(h));
 }
 
-export const BASH_BLOCK_REASON =
-  "RLM mode: reading files via bash is blocked — that dumps file content into the root model's " +
-  "context. All files are pre-loaded in the REPL `context` variable: use repl({code}) with Python " +
-  "string/regex search, and delegate bulk analysis to llm_query / llm_batch / " +
-  "llm_query_chunked. bash is for RUNNING things (tests, builds, git).";
-
 /** Max chars of tool output forwarded to the root model (≈1K tokens). */
 export const TOOL_RESULT_CAP = 4_000;
 

package/src/mode/rlm-mode.ts

@@ -16,11 +16,12 @@ import { resolveSource } from "../context/resolve.ts";
 import { RlmEmitter } from "../tool/rlm-events.ts";
 import { formatError } from "../util/errors.ts";
 import { cheapestModel } from "./llm-model.ts";
-import type { MemoryStore } from "../core/memory.ts";
+import type { SkillStore } from "../config/skillstate.ts";
+import type { RunState } from "../core/run-state.ts";
 import type { RunRlm } from "../core/types.ts";
 import type { SubcallGates } from "../util/concurrency.ts";
 
-export interface RunHandle {
+interface RunHandle {
   readonly abort: () => void;
   readonly done: Promise<RlmResult>;
 }
@@ -28,16 +29,23 @@ export interface RunHandle {
 export interface StartInput {
   readonly rootPrompt: string;
   readonly context: unknown;
+  /** History-as-deliverable opt-out (§12.1): RunState stays off — the archive is the product. */
+  readonly narrative?: boolean;
 }
 
 export class RlmController {
   llmModel: Model<Api> | undefined;
-  savedLlmRef: string | undefined;
+  savedLlmRef?: string;
   /** Set by applyLlmSelection when the user explicitly picks "cheapest (auto)". */
   explicitClearPin = false;
   /** Pinned rlm root/worker model — when unset, child engines follow pi's session model. */
   rlmModel: Model<Api> | undefined;
-  savedRlmRef: string | undefined;
+  savedRlmRef?: string;
+  /** SKILL.state (Workstream B): the session store — hydrated by index.ts at session_start.
+   *  Undefined ⇒ no Ξ composition, no harvest: the headless path runs exactly as built. */
+  skillStore: SkillStore | undefined;
+  /** Root Σ (WS-4): set by the extension — engine-finalize Σ flows to the root tracker. */
+  onRunState: ((state: RunState) => void) | undefined;
   /** Set by applyRlmSelection when the user explicitly picks "(follow session model)". */
   explicitClearRlmPin = false;
   private active: AbortController | null = null;
@@ -45,11 +53,7 @@ export class RlmController {
    *  session_start so BOTH composition roots admit through one pool (audit C1). */
   private sessionGates: (() => SubcallGates) | undefined;
 
-  constructor(
-    public config: RlmConfig,
-    /** v5 durable memory — shared with the repl tool so child runs replay/persist too. */
-    public readonly memory?: MemoryStore,
-  ) {}
+  constructor(public config: RlmConfig) {}
 
   setSessionGates(getGates: () => SubcallGates): void {
     this.sessionGates = getGates;
@@ -101,9 +105,12 @@ export class RlmController {
     if (!this.llmModel && this.savedLlmRef) this.llmModel = resolveModelId(ctx.modelRegistry, this.savedLlmRef);
     if (!this.rlmModel && this.savedRlmRef) this.rlmModel = resolveModelId(ctx.modelRegistry, this.savedRlmRef);
     // The rlm pin wins over the session model; unset → follow pi's active model.
+    // pi's ctx.model is typed Model<any>; runtime models conform to Model<Api> — the two
+    // directives below mark exactly where that external-boundary any enters and leaves.
     const model = this.rlmModel ?? ctx.model ?? cheapestModel(ctx.modelRegistry);
     if (!model) return undefined;
     const llm = this.llmModel ?? cheapestModel(ctx.modelRegistry) ?? model;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     return { model, llm };
   }
 
@@ -112,6 +119,14 @@ export class RlmController {
     return createEngine(deps);
   }
 
+  /** Ξ (Workstream C): BM25 slice of the session SkillState for a root prompt; undefined when
+   *  the store is absent/disabled or nothing is relevant. */
+  private skillBlockFor(query: string): string | undefined {
+    if (this.skillStore === undefined || !this.config.enableSkillState) return undefined;
+    const block = this.skillStore.blockFor(query, this.config.skillStateMaxTokens);
+    return block === "" ? undefined : block;
+  }
+
   /** The ONE engine construction path for this controller (DRY #6 — a second path that
    *  forgets to grow is exactly how issue #4 and audit C1 happened). Protected so tests can
    *  subclass and assert the wiring without touching the network. */
@@ -129,8 +144,9 @@ export class RlmController {
       signal: args.signal,
       emitter: args.emitter,
       limits: limitsFromConfig(this.config),
-      memory: this.memory,
       gates: this.sessionGates?.(),
+      skillStore: this.skillStore,
+      onRunState: this.onRunState,
     });
   }
 
@@ -159,7 +175,14 @@ export class RlmController {
         signal: abortController.signal,
         emitter: emitter ?? new RlmEmitter(),
       });
-      return await engine({ rootPrompt: input.rootPrompt, context: contextValue, depth: 0 });
+      const skillBlock = this.skillBlockFor(input.rootPrompt);
+      return await engine({
+        rootPrompt: input.rootPrompt,
+        context: contextValue,
+        depth: 0,
+        ...(skillBlock === undefined ? {} : { skillBlock }), // Ξ (Workstream C)
+        ...(input.narrative === undefined ? {} : { narrative: input.narrative }),
+      });
     })().finally(() => {
       if (this.active === abortController) this.active = null;
     });

package/src/mode/subagent.ts

@@ -11,9 +11,9 @@
  */
 import { DEFAULT_CONFIG } from "../config/defaults.ts";
 
-export const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
-export const RLM_FORCE_IN_SUBAGENT_ENV = "PI_RLM_FORCE_IN_SUBAGENT";
-export const RLM_DEPTH_ENV = "PI_RLM_DEPTH";
+const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
+const RLM_FORCE_IN_SUBAGENT_ENV = "PI_RLM_FORCE_IN_SUBAGENT";
+const RLM_DEPTH_ENV = "PI_RLM_DEPTH";
 
 /** Cross-process depth from env. Missing / invalid → 0. */
 export function processRlmDepth(): number {
@@ -48,7 +48,7 @@ export function commitSubagentForceActivation(maxDepth: number = DEFAULT_CONFIG.
   if (process.env[RLM_FORCE_IN_SUBAGENT_ENV] !== "1") return;
   if (processRlmDepth() >= maxDepth) return;
   const next = processRlmDepth() + 1;
-  delete process.env[RLM_FORCE_IN_SUBAGENT_ENV];
+  Reflect.deleteProperty(process.env, RLM_FORCE_IN_SUBAGENT_ENV);
   process.env[RLM_DEPTH_ENV] = String(next);
 }
 
@@ -59,7 +59,7 @@ export function commitSubagentForceActivation(maxDepth: number = DEFAULT_CONFIG.
  */
 export function shouldEnforceNativeReaderBlock(opts: {
   readonly enabled: boolean;
-  readonly activeToolNames: readonly string[] | undefined;
+  readonly activeToolNames?: readonly string[];
 }): boolean {
   if (!opts.enabled) return false;
   const names = opts.activeToolNames;