@hicaru/pi-rlm 0.3.15 → 0.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hicaru/pi-rlm",
-	"version": "0.3.15",
+	"version": "0.3.17",
 	"author": "hicaru",
 	"repository": {
 		"type": "git",
@@ -10,9 +10,9 @@
 		"typescript": "^5.0.0"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": "^0.84.1",
-		"@earendil-works/pi-coding-agent": "^0.84.1",
-		"@earendil-works/pi-tui": "^0.84.1",
+		"@earendil-works/pi-ai": "^0.85.1",
+		"@earendil-works/pi-coding-agent": "^0.85.1",
+		"@earendil-works/pi-tui": "^0.85.1",
 		"typebox": "*"
 	},
 	"bugs": {
@@ -52,7 +52,7 @@
 		"node": ">=20"
 	},
 	"dependencies": {
-		"@earendil-works/pi-agent-core": "^0.84.1",
+		"@earendil-works/pi-agent-core": "^0.85.1",
 		"@firecrawl/anydoc": "^0.2.4"
 	}
 }

package/src/bridge/add-context.ts

@@ -24,7 +24,7 @@ import {
 import { resolveSource } from "../context/resolve.ts";
 import { previewText } from "../text/preview.ts";
 
-export interface AddContextBridgeOpts {
+interface AddContextBridgeOpts {
   /** Fixed cwd (headless). Prefer getCwd when the sandbox outlives a single invocation. */
   readonly cwd?: string;
   /** Late-bound cwd (native mode — sandbox handlers outlive a single repl()). */

package/src/bridge/handlers/await.ts

@@ -9,7 +9,7 @@
 import { errorMessage, formatError } from "../../util/errors.ts";
 import type { AwaitResult, SubcallHandlerDeps, TaskEntry } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
-import type { AwaitDeps } from "./task-registry.ts";
+import { entryToAwaitResult, type AwaitDeps } from "./task-registry.ts";
 
 export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
   return async (
@@ -37,7 +37,7 @@ export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
       if (entry.status === "pending") {
         try {
           const resolved = await ad.wait(taskId, timeoutMs);
-          return toAwaitResult(resolved);
+          return entryToAwaitResult(resolved);
         } catch (err: unknown) {
           return {
             ok: false,
@@ -49,7 +49,7 @@ export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
         }
       }
 
-      return toAwaitResult(entry);
+      return entryToAwaitResult(entry);
     }
 
     // Multiple tasks
@@ -91,7 +91,7 @@ export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
       }),
     );
 
-    const awaited = resolved.map(toAwaitResult);
+    const awaited = resolved.map(entryToAwaitResult);
     const allDone = awaited.every((a) => a.status === "done");
     const hasResults = awaited.some((a) => a.results !== undefined);
     const firstError = awaited.find((a) => a.error)?.error;
@@ -99,12 +99,18 @@ export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
     const kind = first?.kind ?? "unknown";
 
     if (hasResults) {
-      const allResults: string[] = [];
+      // Pre-allocated (rule: no .push() growth when the size is computable) — count, then fill.
+      const total = awaited.reduce(
+        (n, a) => n + (a.results !== undefined ? a.results.length : a.result !== undefined ? 1 : 0),
+        0,
+      );
+      const allResults = new Array<string>(total);
+      let n = 0;
       for (const a of awaited) {
         if (a.results !== undefined) {
-          for (const r of a.results) allResults.push(r);
+          for (const r of a.results) allResults[n++] = r;
         } else if (a.result !== undefined) {
-          allResults.push(a.result);
+          allResults[n++] = a.result;
         }
       }
       return {
@@ -131,18 +137,3 @@ export function createAwaitHandler(_deps: SubcallHandlerDeps, ad: AwaitDeps) {
     };
   };
 }
-
-function toAwaitResult(entry: TaskEntry): AwaitResult {
-  const status = entry.status === "pending" ? "error" : entry.status;
-  return {
-    ok: entry.status === "done",
-    task_id: entry.taskId,
-    kind: entry.kind,
-    status,
-    result: entry.result,
-    results: entry.results,
-    error:
-      entry.error ??
-      (entry.status === "pending" ? "Task still pending" : undefined),
-  };
-}

package/src/bridge/handlers/completion.ts

@@ -14,15 +14,33 @@ import { checkResourceLimits } from "../../core/resource-limits.ts";
 import { errorMessage, formatError } from "../../util/errors.ts";
 import { retryPolicy } from "../../util/retry.ts";
 import type { Semaphore } from "../../util/concurrency.ts";
-import type { Invocation, SubcallConfig } from "./types.ts";
+import type { Invocation, SubcallConfig, SubcallHandlerDeps } from "./types.ts";
 
-export interface Complete1Deps {
+interface Complete1Deps {
   readonly leafGate: Semaphore;
   readonly registry: ModelRegistry;
   readonly getLlmModel: () => Model<Api>;
   readonly getConfig: () => SubcallConfig;
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
+  /** SKILL.state (Workstream D): the one grounding seam, projected verbatim from deps. */
+  readonly groundLeaf?: (prompt: string) => string;
+}
+
+/**
+ * AGENTS.md DRY: the ONE projection of SubcallHandlerDeps for complete1 — shared verbatim by
+ * the llm-query and rlm-query handlers. Never inline a second copy.
+ */
+export function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
+  return {
+    leafGate: deps.gates.leaf,
+    registry: deps.registry,
+    getLlmModel: deps.getLlmModel,
+    getConfig: deps.getConfig,
+    signal: deps.signal,
+    onUsage: deps.onUsage,
+    groundLeaf: deps.groundLeaf,
+  };
 }
 
 /**
@@ -41,14 +59,18 @@ export async function complete1(
     timeoutMs: inv.limits.remainingTimeoutMs(),
   });
   if (limitError !== undefined) return limitError;
-  if (prompt.length > config.maxPromptChars) {
+  // Workstream D (DRY #1): the ONE grounding application — llm_query, batch items, rlm→llm
+  // demotion and depth-cap degrade all pass through here, so all of them get Ξ facts or none
+  // does. Below-threshold prompts come back byte-identical from the groundLeaf impl.
+  const grounded = deps.groundLeaf !== undefined ? deps.groundLeaf(prompt) : prompt;
+  if (grounded.length > config.maxPromptChars) {
     return formatError(
-      `sub-LLM prompt exceeded the size limit (${prompt.length.toLocaleString()} chars > ` +
+      `sub-LLM prompt exceeded the size limit (${grounded.length.toLocaleString()} chars > ` +
         `${config.maxPromptChars.toLocaleString()}). Shorten or chunk the prompt before calling llm_query.`,
     );
   }
   try {
-    const messages: ChatMsg[] = [{ role: "user", content: prompt }];
+    const messages: ChatMsg[] = [{ role: "user", content: grounded }];
     const res = await deps.leafGate.run(() =>
       modelComplete(messages, {
         model: deps.getLlmModel(),

package/src/bridge/handlers/emitting.ts

@@ -11,14 +11,14 @@ import { previewText } from "../../text/preview.ts";
 import type { SubcallPhase } from "../../tool/rlm-details.ts";
 import type { Invocation } from "./types.ts";
 
-export interface EmitOpts {
+interface EmitOpts {
   readonly kind: "llm" | "batch";
   readonly label: string;
   readonly args: string;
   readonly model?: string;
 }
 
-export interface EmitSummary {
+interface EmitSummary {
   readonly preview: string;
   readonly error?: string;
   readonly failed?: number;

package/src/bridge/handlers/llm-query.ts

@@ -4,29 +4,20 @@
 
 import type { Usage } from "@earendil-works/pi-ai";
 import { modelRef } from "../../config/settings.ts";
-import { complete1, type Complete1Deps } from "./completion.ts";
-import { emitting, summarizeLeaf, throttleHooks } from "./emitting.ts";
+import { complete1, completeDeps } from "./completion.ts";
+import { emitting, summarizeLeaf, throttleHooks, type EmitNote } from "./emitting.ts";
 import { formatError, errorMessage } from "../../util/errors.ts";
 import { previewText } from "../../text/preview.ts";
-import type { SpawnResult, SubcallHandlerDeps } from "./types.ts";
+import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
 import { ECHO_STUB, taskKey, type TaskLedger } from "../../core/ledger.ts";
 
-const UNWIRED = formatError("RLM bridge not wired for this invocation");
+/** Shared with rlm-query.ts — the unwired rejection sentinel (AGENTS DRY). */
+export const UNWIRED = formatError("RLM bridge not wired for this invocation");
 
-function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
-  return {
-    leafGate: deps.gates.leaf,
-    registry: deps.registry,
-    getLlmModel: deps.getLlmModel,
-    getConfig: deps.getConfig,
-    signal: deps.signal,
-    onUsage: deps.onUsage,
-  };
-}
-
-function displayModel(deps: SubcallHandlerDeps): string | undefined {
+/** Shared with rlm-query.ts — one display-model resolution (AGENTS DRY #3). */
+export function displayModel(deps: SubcallHandlerDeps): string | undefined {
   try {
     const m = deps.getLlmModel();
     return modelRef(m) ?? m.id;
@@ -36,10 +27,36 @@ function displayModel(deps: SubcallHandlerDeps): string | undefined {
 }
 
 /** The ledger active for leaf calls — undefined when disabled by config or not threaded in. */
-function activeLedger(deps: SubcallHandlerDeps): TaskLedger | undefined {
+export function activeLedger(deps: SubcallHandlerDeps): TaskLedger | undefined {
   return deps.getConfig().enableLedger ? deps.ledger : undefined;
 }
 
+/** DRY: one unwired-spawn shape — kind/n vary, everything else is the same rejection.
+ *  Shared with rlm-query.ts. */
+export function unwiredSpawn(kind: SpawnResult["kind"], n: number): SpawnResult {
+  return { ok: false, task_id: null, kind, n, status: "pending", hint: SPAWN_HINT, error: UNWIRED };
+}
+
+/** DRY: the shared leaf recipe — one UI node, one complete1 execution, one summarizer. */
+function emitLeaf(
+  inv: Invocation,
+  deps: SubcallHandlerDeps,
+  prompt: string,
+  exec: (track: (u: Usage) => void, note: EmitNote) => Promise<string>,
+): Promise<string> {
+  return emitting(
+    inv,
+    {
+      kind: "llm",
+      label: "llm_query",
+      args: `prompt: ${previewText(prompt)}`,
+      model: displayModel(deps),
+    },
+    (track, note) => exec(track, note),
+    summarizeLeaf,
+  );
+}
+
 /** v5 TaskLedger routing for ONE leaf prompt (audit H3 — shared by llm_query and every
  *  llm_batch item, which v5 routed through `_spawn_single` too): echo → stub string,
  *  coalesce → the twin's result (bounded wait), run → caller executes then finish/fail.
@@ -84,31 +101,12 @@ export function createLlmQueryHandler(
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "llm",
-        n: 1,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("llm", 1);
 
     const cdeps = completeDeps(deps);
     const runLeaf = (): Promise<string> =>
-      emitting(
-        inv,
-        {
-          kind: "llm",
-          label: "llm_query",
-          args: `prompt: ${previewText(prompt)}`,
-          model: displayModel(deps),
-        },
-        (track: (u: Usage) => void, note) => complete1(inv, prompt, track, cdeps, throttleHooks(note)),
-        summarizeLeaf,
-      );
+      emitLeaf(inv, deps, prompt, (track, note) =>
+        complete1(inv, prompt, track, cdeps, throttleHooks(note)));
     // v5 TaskLedger for leaves: identical prompts coalesce onto one completion (key has no
     // context — a leaf's entire world is the prompt text itself).
     return spawnAndRun(
@@ -132,17 +130,7 @@ export function createLlmBatchHandler(
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "llm_batch",
-        n: prompts.length,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("llm_batch", prompts.length);
 
     const cdeps = completeDeps(deps);
     const ledger = activeLedger(deps);
@@ -155,27 +143,17 @@ export function createLlmBatchHandler(
       () =>
         Promise.all(
           prompts.map((p) =>
-            emitting(
-              inv,
-              {
-                kind: "llm",
-                label: "llm_query",
-                args: `prompt: ${previewText(p)}`,
-                model: displayModel(deps),
-              },
+            emitLeaf(inv, deps, p, (track, note) =>
               // NO outer gate — complete1 takes the single leaf slot per prompt.
               // v5 (audit H3): every item routes through the ledger — duplicate prompts inside
               // one batch (or twins of other in-flight leaves) coalesce instead of paying N times.
-              (track: (u: Usage) => void, note) =>
-                runClaimedLeaf(
-                  ledger,
-                  ledger === undefined ? undefined : leafClaimKey(deps, p),
-                  p,
-                  inv.depth,
-                  () => complete1(inv, p, track, cdeps, throttleHooks(note)),
-                ),
-              summarizeLeaf,
-            ),
+              runClaimedLeaf(
+                ledger,
+                ledger === undefined ? undefined : leafClaimKey(deps, p),
+                p,
+                inv.depth,
+                () => complete1(inv, p, track, cdeps, throttleHooks(note)),
+              )),
           ),
         ),
       deps.trackDetached,

package/src/bridge/handlers/rlm-query.ts

@@ -4,7 +4,7 @@
  * AGENTS.md DRY #2: childRun exists once, here.
  */
 
-import { modelRef } from "../../config/settings.ts";
+import { modelLabelOf } from "../../config/settings.ts";
 import { errorMessage, formatError } from "../../util/errors.ts";
 import { filterContextByPaths } from "../../context/merge.ts";
 import { previewText } from "../../text/preview.ts";
@@ -13,12 +13,11 @@ import { checkResourceLimits } from "../../core/resource-limits.ts";
 import { contextSig, ECHO_STUB, taskKey } from "../../core/ledger.ts";
 import type { Invocation, SpawnResult, SubcallHandlerDeps } from "./types.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
-import { SPAWN_HINT, spawnAndRun, type SpawnDeps } from "./task-registry.ts";
-import { complete1, type Complete1Deps } from "./completion.ts";
+import { spawnAndRun, type SpawnDeps } from "./task-registry.ts";
+import { complete1, completeDeps } from "./completion.ts";
 import { emitting, summarizeLeaf, throttleHooks } from "./emitting.ts";
-import { leafClaimKey, runClaimedLeaf } from "./llm-query.ts";
+import { activeLedger, leafClaimKey, runClaimedLeaf, unwiredSpawn } from "./llm-query.ts";
 
-const UNWIRED = formatError("RLM bridge not wired for this invocation");
 const NO_UNMATCHED: readonly string[] = Object.freeze([]);
 
 function emptyResult(answer: string): RlmResult {
@@ -56,25 +55,9 @@ function childContextFor(
   });
 }
 
-function completeDeps(deps: SubcallHandlerDeps): Complete1Deps {
-  return {
-    leafGate: deps.gates.leaf,
-    registry: deps.registry,
-    getLlmModel: deps.getLlmModel,
-    getConfig: deps.getConfig,
-    signal: deps.signal,
-    onUsage: deps.onUsage,
-  };
-}
-
-/** Ledger active for this call — undefined when disabled by config or not threaded in. */
-function activeLedger(deps: SubcallHandlerDeps) {
-  return deps.getConfig().enableLedger ? deps.ledger : undefined;
-}
-
 function claimKeyFor(deps: SubcallHandlerDeps, kind: "llm" | "rlm", prompt: string, paths: readonly string[], ctx: string): string {
   const rootModel = deps.getModel?.();
-  const modelId = rootModel === undefined ? "" : (modelRef(rootModel) ?? rootModel.id);
+  const modelId = rootModel === undefined ? "" : modelLabelOf(rootModel);
   return taskKey(kind, prompt, paths, modelId, ctx);
 }
 
@@ -111,31 +94,8 @@ async function childRun(
       ? prompt
       : `${prompt}\n\n[rlm] paths=${child.unmatched.join(", ")} matched no files; you received the full context.`;
 
-  // ── v5 memory replay: an identical, still-fresh child answer replays for zero API calls ──
-  const memory = deps.memory;
   const sig = contextSig(child.context);
   const key = claimKeyFor(deps, "rlm", prompt, paths ?? [], sig);
-  if (memory !== undefined && deps.getConfig().enableMemory !== false) {
-    const hit = memory.replay(key);
-    if (hit !== undefined) {
-      const replayId = inv.emitter.emitSubcallCreated({
-        kind: "rlm",
-        parentId: inv.parentId,
-        label: "rlm_query (replay)",
-        detail: prompt.slice(0, 60),
-        depth: childDepth,
-      });
-      inv.emitter.emitSubcallUpdated({ id: replayId, status: "done", resultPreview: hit.result.slice(0, 200) });
-      return {
-        answer: hit.result,
-        iterations: 0,
-        costUsd: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        durationMs: 0,
-      };
-    }
-  }
 
   // ── v5 TaskLedger: echo → stub; duplicate → coalesce onto the existing runner ──────
   const ledger = activeLedger(deps);
@@ -148,8 +108,7 @@ async function childRun(
   // ONE subcall node per childRun (audit C2 / DRY #5): the decision branch reuses it, the
   // run branch reports the engine's turns/cost on it. Never a second emit below.
   const rootModel = deps.getModel?.();
-  const modelLabel =
-    rootModel === undefined ? undefined : (modelRef(rootModel) ?? rootModel.id);
+  const modelLabel = rootModel === undefined ? undefined : modelLabelOf(rootModel);
   const subId = inv.emitter.emitSubcallCreated({
     kind: "rlm",
     parentId: inv.parentId,
@@ -168,13 +127,14 @@ async function childRun(
     const twin = await ledger
       .waitFor(decision.key)
       .catch((err: unknown) => errorMessage(err));
-    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(String(twin).slice(0, 80)) });
-    return emptyResult(String(twin));
+    inv.emitter.emitSubcallUpdated({ id: subId, status: "done", resultPreview: previewText(twin.slice(0, 80)) });
+    return emptyResult(twin);
   }
   if (ledger !== undefined && claimKey !== undefined) {
     ledger.markRunning(claimKey);
   }
 
+  const skillBlock = deps.getSkillBlock?.(prompt);
   const input: RlmInput = {
     rootPrompt,
     context: child.context,
@@ -182,6 +142,9 @@ async function childRun(
     parentNodeId: subId,
     remainingTimeoutMs: remTimeout,
     ledger, // DRY #6: the one seam — children share the parent's blackboard
+    // SKILL.state Ξ (Workstream C, DRY #6): the parent's block rides along — the only
+    // child-RlmInput construction site, so inheritance cannot grow a second path.
+    ...(skillBlock === undefined ? {} : { skillBlock }),
   };
 
   try {
@@ -189,19 +152,6 @@ async function childRun(
     inv.limits.addRaw(res.costUsd, res.inputTokens, res.outputTokens);
     deps.onChildUsage?.(res.costUsd, res.inputTokens, res.outputTokens);
     if (ledger !== undefined && claimKey !== undefined) ledger.finish(claimKey, res.answer);
-    // v5: child answers persist unconditionally — this is what later identical runs replay.
-    if (memory !== undefined && deps.getConfig().enableMemory !== false) {
-      memory.recordEpisode({
-        key,
-        kind: "rlm",
-        model: modelLabel ?? "",
-        prompt,
-        paths: paths ?? [],
-        result: res.answer,
-        tokensIn: res.inputTokens,
-        tokensOut: res.outputTokens,
-      });
-    }
     inv.emitter.emitSubcallUpdated({
       id: subId,
       status: "done",
@@ -225,17 +175,7 @@ export function createRlmQueryHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "rlm",
-        n: 1,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("rlm", 1);
 
     const pathArg = opts.paths;
 
@@ -297,17 +237,7 @@ export function createRlmBatchHandler(deps: SubcallHandlerDeps, sd: SpawnDeps) {
     opts: SubcallOpts,
   ): Promise<SpawnResult> => {
     const inv = deps.resolve(opts, depth);
-    if (inv === null) {
-      return {
-        ok: false,
-        task_id: null,
-        kind: "rlm_batch",
-        n: tasks.length,
-        status: "pending",
-        hint: SPAWN_HINT,
-        error: UNWIRED,
-      };
-    }
+    if (inv === null) return unwiredSpawn("rlm_batch", tasks.length);
 
     const pathArg = opts.paths;
     // No wrapper "rlm_batch ×N" node: every task already gets its own rlm_query node from

package/src/bridge/handlers/task-registry.ts

@@ -7,6 +7,7 @@
  */
 
 import type { AwaitResult, SpawnResult, TaskEntry } from "./types.ts";
+import { formatError, isErrorText } from "../../util/errors.ts";
 
 export const SPAWN_HINT =
   "Call await_task(task_id=...) to get the result — this is NOT the answer.";
@@ -24,6 +25,22 @@ export interface AwaitDeps {
   unawaitedIds(): readonly string[];
 }
 
+/** DRY: the ONE TaskEntry → AwaitResult mapping — shared by the await handler and the registry. */
+export function entryToAwaitResult(entry: TaskEntry): AwaitResult {
+  const status = entry.status === "pending" ? "error" : entry.status;
+  return {
+    ok: entry.status === "done",
+    task_id: entry.taskId,
+    kind: entry.kind,
+    status,
+    result: entry.result,
+    results: entry.results,
+    error:
+      entry.error ??
+      (entry.status === "pending" ? "Task still pending" : undefined),
+  };
+}
+
 export interface TaskRegistry {
   readonly spawnDeps: SpawnDeps;
   readonly awaitDeps: AwaitDeps;
@@ -32,8 +49,8 @@ export interface TaskRegistry {
 }
 
 interface Waiter {
-  resolve: (entry: TaskEntry) => void;
-  reject: (err: Error) => void;
+  readonly resolve: (entry: TaskEntry) => void;
+  readonly reject: (err: Error) => void;
   timer?: ReturnType<typeof setTimeout>;
 }
 
@@ -146,19 +163,7 @@ export function createTaskRegistry(): TaskRegistry {
           error: `Task ${taskId} not found`,
         };
       }
-      const status =
-        entry.status === "pending" ? "error" : entry.status;
-      return {
-        ok: entry.status === "done",
-        task_id: entry.taskId,
-        kind: entry.kind,
-        status,
-        result: entry.result,
-        results: entry.results,
-        error:
-          entry.error ??
-          (entry.status === "pending" ? "Task still pending" : undefined),
-      };
+      return entryToAwaitResult(entry);
     },
   };
 }
@@ -185,14 +190,14 @@ export function spawnAndRun(
       sd.resolve(taskId, result);
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err);
-      sd.reject(taskId, message.startsWith("Error:") ? message : `Error: ${message}`);
+      sd.reject(taskId, isErrorText(message) ? message : formatError(message));
     }
   };
 
   if (trackDetached !== undefined && detached) {
     void trackDetached(run).catch((err: unknown) => {
       const message = err instanceof Error ? err.message : String(err);
-      sd.reject(taskId, message.startsWith("Error:") ? message : `Error: ${message}`);
+      sd.reject(taskId, isErrorText(message) ? message : formatError(message));
     });
   } else {
     void run();

package/src/bridge/handlers/types.ts

@@ -13,7 +13,6 @@ import type { SubcallGates } from "../../util/concurrency.ts";
 import type { SubcallOpts } from "../../sandbox/interrupts.ts";
 import type { RlmEmitter } from "../../tool/rlm-events.ts";
 import type { TaskLedger } from "../../core/ledger.ts";
-import type { MemoryStore } from "../../core/memory.ts";
 
 // ---------------------------------------------------------------------------
 // Spawn / Await / Finish — the three shapes the model sees
@@ -73,7 +72,7 @@ export function limitsFromRemaining(
 
 export interface Invocation {
   readonly emitter: RlmEmitter;
-  readonly parentId: string | undefined;
+  readonly parentId?: string;
   readonly depth: number;
   readonly limits: InvocationLimits;
 }
@@ -91,8 +90,6 @@ export interface SubcallConfig {
   readonly enableLedger?: boolean;
   /** v5: real rlm spawns before demotion to llm (0 = never demote). */
   readonly rlmBudget?: number;
-  /** v5 durable memory gates (optional; omitted → memory off). */
-  readonly enableMemory?: boolean;
   /** v5.1 retry knobs — structural slice of RlmConfig so retryPolicy() can read them. */
   readonly retryMaxAttempts?: number;
   readonly rateLimitMaxAttempts?: number;
@@ -121,8 +118,13 @@ export interface SubcallHandlerDeps {
   readonly trackDetached?: <T>(run: () => Promise<T>) => Promise<T>;
   /** v5 TaskLedger blackboard shared across the whole run tree (claim/coalesce/echo/demote). */
   readonly ledger?: TaskLedger;
-  /** v5 durable memory (session-wide store) for child replay + episode persistence. */
-  readonly memory?: MemoryStore;
+  /** SKILL.state (Workstream D): ground a leaf prompt with verified facts. Applied ONCE in
+   *  complete1 (DRY #1) so every leaf path inherits it; returns the prompt unchanged when
+   *  nothing clears the score threshold — below it, byte-identical. */
+  readonly groundLeaf?: (prompt: string) => string;
+  /** SKILL.state (Workstream C): the parent run's Ξ block source, for childRun to copy
+   *  into the child RlmInput (DRY #6 — one construction site). */
+  readonly getSkillBlock?: (task: string) => string | undefined;
 }
 
 // ---------------------------------------------------------------------------