@mono-agent/agent-runtime 0.20.10 → 0.20.14

package/src/ai/providers/pi-native/session-lifecycle.js

@@ -10,12 +10,13 @@
 // createSessionLiveness primitives so the await-free spans are enforced by
 // construction rather than by inline sequencing.
 
-import { InMemorySessionRepo, JsonlSessionRepo } from "@earendil-works/pi-agent-core";
+import { JsonlSessionRepo, MemorySessionRepo } from "@earendil-works/pi-agent-core";
 import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
-import { open } from "node:fs/promises";
+import { access, open } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { createSessionRegistry } from "../../runtime/sessions.js";
 import { createSessionLiveness } from "../../runtime/session-liveness.js";
+import { createPiSessionAdapter, PI_CONTEXT } from "./harness-adapter.js";
 
 async function syncPath(path) {
   const handle = await open(path, "r");
@@ -40,31 +41,61 @@ async function syncDurableTranscript(entry) {
 }
 
 async function invalidateNativeSession(entry) {
-  await entry.repo.delete(entry.metadata);
   if (entry.durable) {
     const path = entry.metadata?.path;
     if (typeof path !== "string" || !path) {
       throw new Error("Durable Pi session metadata is missing its JSONL path");
     }
+    // Explicit invalidation is idempotent. A preceding failed sync may have
+    // observed that the transcript was already removed outside this process.
+    try {
+      await access(path);
+    } catch (error) {
+      if (error?.code === "ENOENT") return;
+      throw error;
+    }
+  }
+  await entry.repo.delete(entry.metadata, PI_CONTEXT);
+  if (entry.durable) {
+    const path = entry.metadata.path;
     // Make the unlink durable before the registry forgets the busy marker.
     await syncPath(dirname(path));
   }
 }
 
+/**
+ * Release a Pi session handle and remove its repository record as independent
+ * best-effort operations. A close failure must not prevent deletion of a fresh
+ * or otherwise poisoned transcript.
+ * @param {any} session
+ * @param {any} repo
+ * @param {any} [knownMetadata]
+ */
+async function closeAndDeleteSession(session, repo, knownMetadata) {
+  let metadata = knownMetadata;
+  if (!metadata) {
+    try { metadata = await session.getMetadata(); } catch { /* best-effort */ }
+  }
+  try { await session.close(); } catch { /* best-effort */ }
+  if (metadata) {
+    try { await repo.delete(metadata, PI_CONTEXT); } catch { /* best-effort */ }
+  }
+}
+
 // Live pi-native sessions, keyed by provider session id. Entries are
-// { session, metadata, repo, durable, busy } — identical shape and lifecycle
-// policy to the (now-retired) pi-sdk bridge: in-memory transcripts are freed
-// when the registry evicts them; durable (jsonl) transcripts survive eviction
-// so a later resume can reopen them from disk. Registering here gives
+// { metadata, repo, durable, busy }. Pi 0.85 sessions are closed after every
+// turn so their repository record can be reopened safely; the registry owns
+// only liveness and metadata. In-memory transcripts are freed when the registry
+// evicts them; durable (jsonl) transcripts survive eviction. Registering here gives
 // runtime.disposeSession / disposeProviderSession + idle-TTL eviction the same
 // reach over native pi sessions that the legacy bridge had.
-const nativeSessionRepo = new InMemorySessionRepo();
+const nativeSessionRepo = new MemorySessionRepo();
 const nativeSessions = createSessionRegistry({
   isBusy: (entry) => entry.busy === true,
   onSync: syncDurableTranscript,
   onEvict: async (entry, reason) => {
-    // Ordinary disposal/TTL only drops the live handle so durable sessions can
-    // reopen after restart. Explicit invalidation means the host rejected the
+    // Ordinary disposal/TTL only drops registry metadata so durable sessions
+    // can reopen later. Explicit invalidation means the host rejected the
     // turn before canonical history commit; that poisoned transcript must be
     // deleted too or it could silently reappear on the next stable-id resume.
     if (reason === "invalidated") {
@@ -75,7 +106,7 @@ const nativeSessions = createSessionRegistry({
       return;
     }
     if (entry.durable) return;
-    await entry.repo.delete(entry.metadata);
+    await entry.repo.delete(entry.metadata, PI_CONTEXT);
   },
 });
 const liveness = createSessionLiveness(nativeSessions);
@@ -88,7 +119,7 @@ export function resolveDurableNativeSessionRepo(piSessionsRoot) {
   let repo = durableNativeSessionRepos.get(root);
   if (!repo) {
     repo = new JsonlSessionRepo({
-      fs: new NodeExecutionEnv({ cwd: process.cwd() }),
+      fileSystem: new NodeExecutionEnv({ cwd: process.cwd() }),
       sessionsRoot: root,
     });
     durableNativeSessionRepos.set(root, repo);
@@ -118,19 +149,19 @@ export async function retireDurableNativeSession(providerSessionId, piSessionsRo
 
   const repo = resolveDurableNativeSessionRepo(piSessionsRoot);
   if (!repo) throw new Error("Durable Pi session repository is unavailable");
-  const matches = (await repo.list()).filter((entry) => entry?.id === providerSessionId);
+  const matches = (await repo.list(undefined, PI_CONTEXT)).filter((entry) => entry?.id === providerSessionId);
   const changedDirectories = new Set();
   for (const metadata of matches) {
     if (typeof metadata?.path !== "string" || !metadata.path) {
       throw new Error(`Durable Pi session ${providerSessionId} has invalid metadata`);
     }
-    await repo.delete(metadata);
+    await repo.delete(metadata, PI_CONTEXT);
     changedDirectories.add(dirname(metadata.path));
   }
   for (const directory of changedDirectories) await syncPath(directory);
   if (changedDirectories.size > 0) await syncPath(resolve(piSessionsRoot));
 
-  const remaining = (await repo.list()).filter((entry) => entry?.id === providerSessionId);
+  const remaining = (await repo.list(undefined, PI_CONTEXT)).filter((entry) => entry?.id === providerSessionId);
   if (remaining.length > 0) {
     throw new Error(`Durable Pi session ${providerSessionId} could not be retired completely`);
   }
@@ -158,10 +189,9 @@ function isSafeSessionId(id) {
 
 async function reopenDurableNativeSession(repo, sessionId) {
   try {
-    const metadata = (await repo.list()).find((entry) => entry?.id === sessionId);
+    const metadata = (await repo.list(undefined, PI_CONTEXT)).find((entry) => entry?.id === sessionId);
     if (!metadata) return null;
-    const session = await repo.open(metadata);
-    return { session, metadata, repo, durable: true, busy: false };
+    return { metadata, repo, durable: true, busy: false };
   } catch {
     return null;
   }
@@ -185,9 +215,9 @@ function sessionUnavailableResult({
     usage: {},
     durationMs: Date.now() - start,
     numTurns: 0,
-    model: resolved?.reference || resolved?.model || null,
+    model: resolved?.reference || (resolved?.provider && resolved?.model ? `${resolved.provider}:${resolved.model}` : null),
     effort: options.effort || null,
-    sdk: resolved?.sdk || "pi",
+    sdk: "pi",
     cancelled: false,
     error: errorMessage,
     failureKind,
@@ -290,11 +320,14 @@ export async function resolveSession(runState, {
         } else {
           // Reserved the id with a busy placeholder BEFORE the create await so a
           // second concurrent first turn observes busy and returns session_busy.
-          // The keep-alive success path (reservation.commit with busy:false)
-          // overwrites this placeholder on success; the drop/abort/catch paths
-          // release it. Keyed by requestedSessionId === providerSessionId.
+          // The keep-alive success path overwrites this placeholder with an
+          // entry that remains busy until its harness closes; drop/abort/catch
+          // paths release it. Keyed by requestedSessionId === providerSessionId.
           runState.reservation = reservation;
-          runState.session = await durableRepo.create({ id: providerSessionId, cwd: cwd || process.cwd() });
+          runState.session = createPiSessionAdapter(await durableRepo.create(
+            { id: providerSessionId, cwd: cwd || process.cwd() },
+            PI_CONTEXT,
+          ));
           runState.createdOnMiss = true;
         }
       } else {
@@ -353,14 +386,28 @@ export async function resolveSession(runState, {
         };
       }
       runState.sessionEntry = claimed.entry;
-      runState.session = claimed.entry.session;
+      try {
+        runState.session = createPiSessionAdapter(await claimed.entry.repo.open(
+          claimed.entry.metadata,
+          PI_CONTEXT,
+        ));
+      } catch (error) {
+        // The claim made this registry entry busy. An open failure means the
+        // entry cannot be driven, so remove its liveness record before
+        // propagating; otherwise every later resume retries the same broken
+        // entry forever. Preserve the durable transcript for a later cold
+        // reopen/recovery attempt.
+        liveness.release(requestedSessionId);
+        runState.sessionEntry = null;
+        throw error;
+      }
     }
   } else {
     // Fresh runs persist into the durable jsonl repo when piSessionsRoot is
     // set, so a kept-alive session can be reopened from disk after the live
     // entry is evicted; otherwise the in-memory repo is used.
-    runState.session = await (durableRepo || nativeSessionRepo)
-      .create({ id: providerSessionId, cwd: cwd || process.cwd() });
+    runState.session = createPiSessionAdapter(await (durableRepo || nativeSessionRepo)
+      .create({ id: providerSessionId, cwd: cwd || process.cwd() }, PI_CONTEXT));
   }
   return { done: false };
 }
@@ -379,7 +426,10 @@ export async function discardUncommittedSession(runState, { durableRepo }) {
   // transcript was appended yet (prompt never ran), so the live session is
   // already at its pre-turn leaf and needs no rollback.
   if (runState.session && !runState.sessionEntry) {
-    try { await (durableRepo || nativeSessionRepo).delete(await runState.session.getMetadata()); } catch { /* best-effort */ }
+    await closeAndDeleteSession(
+      runState.session,
+      durableRepo || nativeSessionRepo,
+    );
   }
   // Drop the create-on-miss BUSY reservation too, else the busy placeholder
   // leaks and every future resume of this conversation's stable id returns
@@ -419,16 +469,16 @@ export async function commitSession(runState, {
       } else {
         const metadata = await session.getMetadata();
         const entry = {
-          session,
           metadata,
           repo: durableRepo || nativeSessionRepo,
           durable: !!durableRepo,
-          busy: false,
+          busy: true,
         };
         // A create-on-miss reservation is overwritten by its commit (same id);
         // a plain fresh keep-alive run registers directly.
         if (reservation) reservation.commit(entry);
         else nativeSessions.set(providerSessionId, entry, { idleTimeoutMs: sessionTtlMs });
+        runState.registeredSessionEntry = entry;
       }
     } catch (err) {
       // Session persistence must never fail the run; drop the (now
@@ -442,7 +492,7 @@ export async function commitSession(runState, {
       if (requestedSessionId) nativeSessions.delete(requestedSessionId);
       const broken = sessionEntry;
       if (broken) {
-        try { await broken.repo.delete(broken.metadata); } catch { /* best-effort */ }
+        await closeAndDeleteSession(session, broken.repo, broken.metadata);
       }
     }
   } else if (sessionEntry) {
@@ -463,9 +513,7 @@ export async function commitSession(runState, {
     // (the success keep-alive path overwrites it with the finalized entry, so
     // it is only this drop branch that must clean it up).
     if (reservation) reservation.release();
-    try {
-      await (durableRepo || nativeSessionRepo).delete(await session.getMetadata());
-    } catch { /* best-effort */ }
+    await closeAndDeleteSession(session, durableRepo || nativeSessionRepo);
   }
 }
 
@@ -487,7 +535,7 @@ export async function rollbackAbortedTurn(runState, { requestedSessionId, provid
     nativeSessions.delete(requestedSessionId);
   } else {
     nativeSessions.delete(providerSessionId);
-    try { await (durableRepo || nativeSessionRepo).delete(await session.getMetadata()); } catch { /* best-effort */ }
+    await closeAndDeleteSession(session, durableRepo || nativeSessionRepo);
   }
 }
 
@@ -495,7 +543,8 @@ export async function rollbackAbortedTurn(runState, { requestedSessionId, provid
  * Outer-catch session cleanup: drop a just-created fresh durable session, drop a
  * create-on-miss reservation placeholder, and roll a resumed session back to its
  * pre-turn leaf for host/runtime-side throws that landed after the harness
- * already mutated the live session.
+ * already mutated the live session. Resumed handles are always closed here so
+ * setup failures before a harness is returned cannot leave the repo wedged.
  * @param {any} runState
  * @param {{durableRepo: any}} params
  */
@@ -509,7 +558,7 @@ export async function cleanupSessionOnThrow(runState, { durableRepo }) {
   // resumed user session here would be data loss) and never when the throw
   // preceded session create.
   if (session && !sessionEntry) {
-    try { await (durableRepo || nativeSessionRepo).delete(await session.getMetadata()); } catch { /* best-effort */ }
+    await closeAndDeleteSession(session, durableRepo || nativeSessionRepo);
   }
   // Drop a create-on-miss BUSY placeholder (R8) left in the registry by a throw
   // during/after the reservation — including a throw inside the create await
@@ -522,8 +571,14 @@ export async function cleanupSessionOnThrow(runState, { durableRepo }) {
   // harness already mutated the live session. Mirrors the success-path
   // rollback: move the live session back to the pre-turn leaf so the failed
   // turn never leaks into a later resume. Gated on `sessionEntry &&
-  // baselineLeafId` so it only fires for resumes that captured a baseline.
-  if (sessionEntry && baselineLeafId) {
-    try { await session.moveTo(baselineLeafId); } catch { /* best-effort */ }
+  // baselineLeafId` so rollback only fires for resumes that captured a baseline.
+  // Closing is independently gated on the resumed session existing: a failure
+  // may land before the baseline was readable, but that handle must still be
+  // released without deleting the user-owned transcript.
+  if (sessionEntry && session) {
+    if (baselineLeafId) {
+      try { await session.moveTo(baselineLeafId); } catch { /* best-effort */ }
+    }
+    try { await session.close(); } catch { /* best-effort */ }
   }
 }

package/src/ai/providers/pi-native/stream-subscriber.js

@@ -76,8 +76,8 @@ function toolResultOutcome(result) {
 
 /**
  * Build the harness subscribe handler. `harness` is passed for the maxTurns
- * abort; it is already constructed when this is wired (subscribe follows the
- * AgentHarness constructor).
+ * abort; it is already constructed when this is wired (subscribe follows
+ * AgentHarness.create()).
  * @param {StreamSubscriberState} runState
  * @param {{onEvent: (event: any) => void, options: any, toolLimits: any, harness: any, sdk: string, model: string}} deps
  * @returns {(event: any) => void}
@@ -107,7 +107,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
           onEvent({ type: "assistant", message: { content: [{ type: "thinking", text: streamEvent.content }] } });
         }
       }
-    } else if (event.type === "message_end") {
+    } else if (event.type === "message_end" && event.message?.role === "assistant") {
       const contextUsage = contextUsageFromAssistantMessage(event.message);
       if (contextUsage) {
         const contextWindow = Number(harness?.getModel?.()?.contextWindow) || 0;
@@ -124,6 +124,24 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
           tokens: contextUsage,
         });
       }
+      const hasVisibleContent = Array.isArray(event.message?.content)
+        && event.message.content.some((block) => block
+          && typeof block === "object"
+          && ((block.type === "text"
+            && typeof block.text === "string"
+            && block.text.length > 0)
+            || (block.type === "thinking"
+              && ((typeof block.thinking === "string" && block.thinking.length > 0)
+                || (typeof block.text === "string" && block.text.length > 0)))));
+      if (hasVisibleContent) {
+        const messageId = typeof event.message?.id === "string" && event.message.id.trim().length > 0
+          ? event.message.id
+          : undefined;
+        onEvent({
+          type: "assistant_message_boundary",
+          ...(messageId === undefined ? {} : { messageId }),
+        });
+      }
     } else if (event.type === "tool_execution_start") {
       if (event.toolName) runState.lastToolName = event.toolName;
       if (event.toolCallId) runState.toolStartTimes.set(event.toolCallId, Date.now());
@@ -198,7 +216,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
       });
     } else if (event.type === "turn_end") {
       runState.turnCount += 1;
-      // NON-DELEGABLE (verified against @earendil-works/pi-agent-core 0.80.3).
+      // NON-DELEGABLE (verified against @earendil-works/pi-agent-core 0.85.0).
       // pi's only after-turn stop hook is `shouldStopAfterTurn` on the LOW-LEVEL
       // `AgentLoopConfig` (dist/types.d.ts) — the config passed to the raw
       // `agentLoop`. It is NOT surfaced on `AgentHarnessOptions`
@@ -217,7 +235,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
         && runState.turnCount >= Number(options.maxTurns)
         && event.message?.stopReason === "toolUse") {
         runState.maxTurnsHit = true;
-        harness.abort();
+        void Promise.resolve(harness.abort()).catch(() => {});
       }
     }
   };

package/src/ai/providers/pi-native/turn-runner.js

@@ -7,7 +7,6 @@
 // state; run state (harness, removeAbortHandler, externalAbort) lives on the
 // caller-owned runState.
 
-import { AgentHarness } from "@earendil-works/pi-agent-core";
 import {
   createStructuredOutputTool,
   getPiBuiltinTools,
@@ -17,6 +16,7 @@ import { createNodeReplController } from "../../../agent/tools/node-repl.js";
 import { createWebToolController } from "../../../agent/tools/web-controller.js";
 import { readToolRuntime } from "../../../agent/tools/shared/runtime-context.js";
 import { formatLiveInputGuidance } from "../../live-input-prompt.js";
+import { createPiHarnessAdapter } from "./harness-adapter.js";
 import { appendStructuredOutputInstruction } from "./structured-output.js";
 import { createStreamSubscriber } from "./stream-subscriber.js";
 
@@ -121,13 +121,13 @@ export async function buildTurnTools(runState, {
       nodeReplController,
       webController,
       processJobsController: options.processJobs,
+      monitorsController: options.monitors,
       toolExecutionMode,
       subagents: options.subagents,
       // The child inherits the parent's route and workspace unless its profile
       // pins a model; the tool closure reads these to build each child request.
       subagentContext: {
         model: options.model,
-        executionMode: options.executionMode,
         cwd: options.cwd,
         parentRunId: runCtx?.runId,
         // Same policy + engine this turn's own tools are confined by, so a
@@ -251,7 +251,7 @@ export function toolResultErrorOverride(details) {
   return failed ? { isError: true } : undefined;
 }
 
-export function buildTurnHarness(runState, {
+export async function buildTurnHarness(runState, {
   session,
   piModels,
   model,
@@ -263,18 +263,9 @@ export function buildTurnHarness(runState, {
   maxRetries,
   maxRetryDelayMs,
   steeringMode,
-  onEvent,
   options,
-  toolLimits,
-  sdk,
-  reference,
 }) {
-  // pi-agent-core 0.83.0 removed `env` from AgentHarnessOptions: an
-  // ExecutionEnv now reaches tools through the generic per-turn `toolContext`
-  // instead. mono-agent needs neither — it uses none of pi's built-in
-  // file/shell tools, and its own tools close over what they need — so the
-  // option is dropped rather than migrated.
-  const harness = new AgentHarness({
+  const harness = await createPiHarnessAdapter(session, {
     session,
     models: piModels,
     model,
@@ -297,8 +288,37 @@ export function buildTurnHarness(runState, {
   // every resolved execute(), so without this the model would be told a failed,
   // timed-out, or empty delegation succeeded.
   harness.on("tool_result", (event) => toolResultErrorOverride(event?.details));
+  // Pi 0.85 records in-flight work durably. mono-agent tools do not yet use the
+  // new replay-memo contract, so abort an interrupted operation instead of
+  // risking a duplicate external effect. Do this before subscribing so stale
+  // recovery events cannot contaminate the new run's transcript counters.
+  try {
+    await harness.abortOpenOperations();
+  } catch (error) {
+    try { await harness.close(); } catch { /* best-effort */ }
+    throw error;
+  }
+
   runState.harness = harness;
 
+  return harness;
+}
+
+/**
+ * Subscribe only after prior history has been seeded. Pi emits message
+ * lifecycle events for manual appendMessage() calls; subscribing earlier makes
+ * restored assistant messages look like fresh output boundaries.
+ * @param {any} runState
+ * @param {{harness: any, onEvent: (event: any) => void, options: any, toolLimits: any, sdk: string, reference: string}} deps
+ */
+export function activateTurnHarness(runState, {
+  harness,
+  onEvent,
+  options,
+  toolLimits,
+  sdk,
+  reference,
+}) {
   harness.subscribe(createStreamSubscriber(runState, {
     onEvent,
     options,
@@ -310,13 +330,12 @@ export function buildTurnHarness(runState, {
 
   const abortHandler = () => {
     runState.externalAbort = true;
-    harness.abort();
+    void harness.abort().catch(() => {});
   };
   if (options.abortSignal) {
     options.abortSignal.addEventListener("abort", abortHandler, { once: true });
     runState.removeAbortHandler = () => options.abortSignal.removeEventListener?.("abort", abortHandler);
   }
-  return harness;
 }
 
 /**

package/src/ai/providers/pi-native.js

@@ -74,6 +74,7 @@ import {
   runReactiveCompaction,
 } from "./pi-native/compaction-driver.js";
 import {
+  activateTurnHarness,
   buildTurnHarness,
   buildTurnTools,
   runHarnessPrompt,
@@ -83,9 +84,10 @@ import {
 import { resolvePiTransport } from "./pi-native/transport.js";
 
 /**
- * Pi 0.80.6 exposes per-tool execution markers but not AgentHarness's global
- * toolExecution option. Resolve mono-agent's programmatic mode once per run;
- * individual tool builders then mark stateful/mutating tools sequential.
+ * Resolve mono-agent's programmatic mode once per run. Tool builders mark
+ * stateful/mutating tools sequential; the Pi 0.85 harness adapter promotes any
+ * such marker to its global toolExecution setting because mixed scheduling is
+ * no longer available upstream.
  */
 export function resolvePiToolExecutionMode(options = {}) {
   const warnings = [];
@@ -258,6 +260,14 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
   // an intermediate layer flattens the Error to its message.
   installTransportErrorProbe();
   const resolved = options.model;
+  if (
+    typeof resolved?.provider !== "string"
+    || resolved.provider.length === 0
+    || typeof resolved.model !== "string"
+    || resolved.model.length === 0
+  ) {
+    throw new Error("invalid pi model reference: provider and model are required");
+  }
   const start = Date.now();
   const events = [];
   const runtimeWarnings = [];
@@ -304,6 +314,10 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
     },
     session: null,
     sessionEntry: null,
+    // Fresh keep-alive sessions are registered busy until the harness closes;
+    // this prevents another turn from reopening the same repo record while its
+    // first handle is still live.
+    registeredSessionEntry: null,
     // True when a requestedSessionId had no live entry AND no durable transcript,
     // so a fresh durable session was created under that id (cross-restart resume,
     // first turn for the conversation). Distinct from a true resume (sessionEntry
@@ -352,13 +366,17 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
     }
     emitCaptured(events, options.onEvent, event);
   };
+  // Exec and Monitor both run a command a host configured Bash's risk tier for.
+  // Leaving either unmapped would let the same shell command take a lower
+  // approval tier simply by being started through a different tool.
+  const bashRiskTier = options.toolRiskTiers?.Bash;
   const approvalRiskTiers = {
     ...(options.toolRiskTiers || {}),
-    ...(
-      options.toolRiskTiers?.Exec === undefined && options.toolRiskTiers?.Bash !== undefined
-        ? { Exec: options.toolRiskTiers.Bash }
-        : {}
-    ),
+    ...(bashRiskTier !== undefined
+      ? Object.fromEntries(["Exec", "Monitor"]
+        .filter((name) => options.toolRiskTiers?.[name] === undefined)
+        .map((name) => [name, bashRiskTier]))
+      : {}),
   };
   const approvalManager = options.onToolApprovalRequest
     ? createApprovalManager({
@@ -422,8 +440,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       : resolvePiRuntimeModel(resolved, options);
     const capabilities = runtime.capabilities || {};
     const effectiveThinkingLevel = thinkingLevelForEffort(options.effort || "medium", capabilities);
-    const reference = resolved.reference
-      || (resolved.sdk === "pi" ? `pi:${resolved.provider}:${resolved.model}` : `${resolved.sdk}:${resolved.model}`);
+    const reference = resolved.reference || `${resolved.provider}:${resolved.model}`;
 
     // Resolve the typed `toolLimits` / `compaction` policy objects against the
     // deprecated `settings` fallback (per-group precedence: a present typed
@@ -486,15 +503,17 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       ? Number(options.maxRetryDelayMs)
       : 60_000;
     // Steering controls user follow-up delivery, not tool scheduling. Keep it
-    // independent from piToolExecutionMode; tools carry their own executionMode.
+    // independent from piToolExecutionMode; the adapter derives Pi 0.85's
+    // global scheduling mode from the tools' executionMode markers.
     const toolSteeringMode = "one-at-a-time";
 
     const piModels = buildRunModels(runtime, options, runtimeWarnings);
 
-    // Construct the harness, subscribe the stream normalizer, and wire the
-    // external abort handler (which sets runState.externalAbort and aborts the
-    // harness). Sets runState.harness + runState.removeAbortHandler.
-    harness = buildTurnHarness(runState, {
+    // Construct the harness and recover any interrupted durable operation.
+    // Stream subscription and the external abort handler are activated only
+    // after prior transcript seeding, so manual append lifecycle events cannot
+    // surface as output from this run.
+    harness = await buildTurnHarness(runState, {
       session: runState.session,
       piModels,
       model: runtime.model,
@@ -506,11 +525,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       maxRetries,
       maxRetryDelayMs,
       steeringMode: toolSteeringMode,
-      onEvent,
       options,
-      toolLimits,
-      sdk: resolved.sdk,
-      reference,
     });
 
     // Seed prior transcript (everything before the trailing user turn) into the
@@ -536,6 +551,15 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       try { runState.baselineLeafId = await runState.session.getLeafId(); } catch { /* best-effort */ }
     }
 
+    activateTurnHarness(runState, {
+      harness,
+      onEvent,
+      options,
+      toolLimits,
+      sdk: "pi",
+      reference,
+    });
+
     // Live steering: consume follow-up messages and steer the harness mid-run.
     // The consumer is tied to run completion so it stops steering once the run
     // finishes and does not swallow messages meant for a later turn.
@@ -584,7 +608,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
 
     onEvent({
       type: "provider_request_started",
-      sdk: resolved.sdk,
+      sdk: "pi",
       model: reference,
       runtime: "pi",
       timestamp: Date.now(),
@@ -765,7 +789,7 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       // runtime.compaction.enabled. See docs/reference/feature-registry.md runtime.context-compaction.
       contextCompactionApplied: runState.compaction.policy?.enabled ? runState.compaction.applied : null,
     });
-    emitCapabilitiesResolved(onEvent, { sdk: resolved.sdk, model: reference, capabilitiesUsed });
+    emitCapabilitiesResolved(onEvent, { sdk: "pi", model: reference, capabilitiesUsed });
 
     // Re-check the abort signal: a cancel can land during the post-run work above
     // (live-input teardown, structured-output finalization retry) after the line
@@ -861,7 +885,9 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       piTransport,
     });
   } finally {
+    try { await harness?.close?.(); } catch { /* best-effort */ }
     if (runState.sessionEntry) runState.sessionEntry.busy = false;
+    if (runState.registeredSessionEntry) runState.registeredSessionEntry.busy = false;
     runState.removeAbortHandler?.();
     try {
       await closeRunTools();
@@ -875,6 +901,6 @@ export const piNativeRuntimeBridge = {
   id: "pi",
   kind: "pi",
   capabilities: runtimeCapabilities("pi"),
-  supports: (ref) => ref?.sdk === "pi",
+  supports: (ref) => Boolean(ref?.provider && ref?.model),
   execute: generatePiNativeResponse,
 };