zob-harness 0.9.1 → 0.9.2

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts

@@ -97,6 +97,21 @@ function readLeasesFromDir(dir: string, nowMs: number, teamName?: string): ZobLi
     .map((lease) => leaseToPeerCard(lease, nowMs));
 }
 
+function peerRegistryKey(peer: Pick<ZobLivePeerCard, "projectId" | "roleId" | "sessionHash">): string {
+  return `${peer.projectId}:${peer.roleId}:${peer.sessionHash}`;
+}
+
+function mergeLeaseBackedAndAdhocPeers(leasePeers: ZobLivePeerCard[], agentPeers: ZobLivePeerCard[]): ZobLivePeerCard[] {
+  const byKey = new Map<string, ZobLivePeerCard>();
+  for (const peer of leasePeers) byKey.set(peerRegistryKey(peer), peer);
+  for (const peer of agentPeers) {
+    if (peer.zpeerAdhoc !== true) continue;
+    const key = peerRegistryKey(peer);
+    if (!byKey.has(key)) byKey.set(key, peer);
+  }
+  return [...byKey.values()];
+}
+
 function boundedOfflinePeerRetentionMs(value: number | undefined): number {
   const env = Number.parseInt(process.env.ZOB_COMS_OFFLINE_PEER_RETENTION_MS ?? "", 10);
   const raw = typeof value === "number" && Number.isFinite(value) ? value : Number.isFinite(env) ? env : DEFAULT_OFFLINE_PEER_RETENTION_MS;
@@ -514,8 +529,13 @@ export function unregisterCurrentZobLivePeer(repoRoot: string, teamName = "zob-c
 export function readZobLiveRegistrySnapshot(repoRoot: string, teamName?: string): ZobLiveRegistrySnapshot {
   const { dir, projectId, kind } = projectLeasesDir(repoRoot);
   const nowMs = Date.now();
-  if (existsSync(dir)) return buildSnapshot(projectId, kind, readLeasesFromDir(dir, nowMs, teamName), teamName);
   const agents = projectAgentsDir(repoRoot);
+  if (existsSync(dir)) {
+    return buildSnapshot(projectId, kind, mergeLeaseBackedAndAdhocPeers(
+      readLeasesFromDir(dir, nowMs, teamName),
+      readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName),
+    ), teamName);
+  }
   return buildSnapshot(agents.projectId, agents.kind, readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName), teamName);
 }
 
@@ -523,9 +543,10 @@ export function readZobLiveRegistryAllProjectsSnapshot(repoRoot: string, teamNam
   const { projectId, kind } = projectAgentsDir(repoRoot);
   const nowMs = Date.now();
   const leaseDirs = allProjectLeasesDirs();
+  const agentPeers = allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
   const hasLeaseDomain = leaseDirs.some((dir) => existsSync(dir));
   const peers = hasLeaseDomain
-    ? leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName))
-    : allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
+    ? mergeLeaseBackedAndAdhocPeers(leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName)), agentPeers)
+    : agentPeers;
   return buildSnapshot(projectId, kind, peers, teamName);
 }

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/types.ts

@@ -109,6 +109,7 @@ export interface ZobLivePeerCard {
   zpeerActiveRoomId?: string;
   zpeerMemberships?: ZpeerRoomMembership[];
   zpeerLocalOnly?: true;
+  zpeerAdhoc?: true;
   staleAfterMs: number;
   offlineAfterMs: number;
   bodyStored: false;

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts

@@ -234,7 +234,7 @@ export function refreshZpeerSelf(repoRoot: string, peer: ZobLivePeerCard, roomId
   const ensured = ensureZpeerFields(repoRoot, peer, roomId, alias, restoredMemberships);
   if (!hasLocalSocketEndpointEvidence(ensured)) return ensured;
   const refreshed = writeZobLivePeerCard(repoRoot, { ...ensured, heartbeatAt: new Date().toISOString(), status: "online" });
-  writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
+  if (refreshed.zpeerAdhoc !== true) writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
   return refreshed;
 }
 
@@ -479,8 +479,10 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
   };
 
   if (!selfMembership) return finish("attempt", { status: "blocked", reason: `current peer is not a member of room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
-  const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
-  if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  if (self.zpeerAdhoc !== true) {
+    const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
+    if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  }
   if (selfMembership.role === "observer") return finish("attempt", { status: "blocked", reason: `current peer is observer-only in room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
   if (!targetAlias) return finish("attempt", { status: "blocked", reason: "invalid target alias", bodyStored: false });
   if (!transientPrompt.trim()) return finish("attempt", { status: "blocked", reason: "empty peer prompt", targetAlias, bodyStored: false });

package/.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { discoverAgents } from "./agents.js";
 import { SUPERVISED_READONLY_CHILD_TOOLS } from "../../core/constants.js";
@@ -24,6 +24,28 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
   return { command: "pi", args };
 }
 
+function childModelPattern(ctx: ExtensionContext, agent: HarnessAgent, modelOverride: string | undefined): string | undefined {
+  if (modelOverride?.trim()) return modelOverride.trim();
+  if (agent.model?.trim()) return agent.model.trim();
+  const model = ctx.model;
+  if (!model?.provider || !model.id) return undefined;
+  return `${model.provider}/${model.id}`;
+}
+
+function providerFromModelPattern(model: string | undefined): string | undefined {
+  if (!model) return undefined;
+  const [provider] = model.split("/");
+  return provider && provider !== model ? provider : undefined;
+}
+
+function resolveCodexFastModeExtension(ctx: ExtensionContext, model: string | undefined): string | undefined {
+  const provider = ctx.model?.provider ?? providerFromModelPattern(model);
+  const usesCodexProvider = provider === "openai-codex" || provider === "codex-auto" || provider?.startsWith("codex-") === true;
+  if (!usesCodexProvider) return undefined;
+  const extensionPath = join(getAgentDir(), "extensions", "codex-fast-mode.ts");
+  return existsSync(extensionPath) ? extensionPath : undefined;
+}
+
 const CHILD_THINKING_LEVELS = new Set<string>(["low", "medium", "high", "xhigh"]);
 
 function validateChildThinkingOverride(thinking: string | undefined, fieldName = "thinking"): string[] {
@@ -90,13 +112,14 @@ async function runChildAgent(
   pathPolicy?: { allowedPaths?: string[]; forbiddenPaths?: string[]; sandboxRoot?: string },
   thinkingOverride?: ChildThinkingLevel,
 ): Promise<ChildResult> {
+  const resolvedModel = childModelPattern(ctx, agent, modelOverride);
   const result: ChildResult = {
     agent: agent.name,
     task,
     exitCode: 0,
     output: "",
     stderr: "",
-    model: modelOverride ?? agent.model,
+    model: resolvedModel,
     usage: usageEmpty(),
   };
 
@@ -123,10 +146,12 @@ async function runChildAgent(
 
   try {
     const childSafetyExtension = join(ctx.cwd, ".pi", "extensions", "zob-child-safety", "index.ts");
+    const childCodexFastModeExtension = resolveCodexFastModeExtension(ctx, resolvedModel);
     const args = ["--mode", "json", "-p", "--no-extensions"];
+    if (childCodexFastModeExtension) args.push("-e", childCodexFastModeExtension);
     if (existsSync(childSafetyExtension)) args.push("-e", childSafetyExtension);
     args.push("--session", sessionPath);
-    const model = modelOverride ?? agent.model;
+    const model = resolvedModel;
     if (model) args.push("--model", model);
     const thinking = resolveChildThinking(agent, thinkingOverride);
     if (thinking) args.push("--thinking", thinking);

package/.pi/extensions/zob-harness/src/runtime/events.ts

@@ -132,6 +132,19 @@ function activeZagentState(state: HarnessRuntimeState): ActiveZagentState | unde
   return state.zagent.id ? state.zagent as ActiveZagentState : undefined;
 }
 
+function zpeerStableTeamAgentLeaseRequired(zagent: ActiveZagentState | undefined): boolean {
+  return Boolean(
+    zagent?.id
+    || process.env.ZOB_ZAGENT_ID?.trim()
+    || process.env.ZOB_ZTEAM_ID?.trim()
+    || process.env.ZOB_COMS_ROLE_ID?.trim(),
+  );
+}
+
+function withZpeerLeaseMode<T extends NonNullable<HarnessRuntimeState["zobLive"]["peerCard"]>>(peer: T, useStableTeamAgentLease: boolean): T {
+  return { ...peer, zpeerAdhoc: useStableTeamAgentLease ? undefined : true } as T;
+}
+
 function formatScopedZteamModeLabel(scopedMode: ActiveZagentState["scopedMode"]): string | undefined {
   if (!scopedMode?.active || !scopedMode.teamId || !scopedMode.modeId || !scopedMode.baseMode) return undefined;
   return `zob:${scopedMode.baseMode}@${scopedMode.teamId}/${scopedMode.modeId}`;
@@ -511,6 +524,7 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
   if (carryoverProfile?.zagentId && state.zagent.id !== carryoverProfile.zagentId) loadActiveZagentById(state, repoRoot, carryoverProfile.zagentId);
   const sharedZpeerProfile = zpeerProfile ? zpeerProfileIdIsSharedFallback(zpeerProfile.profileId) : false;
   const zagent = activeZagentState(state);
+  const useStableTeamAgentLease = zpeerStableTeamAgentLeaseRequired(zagent);
   const zagentMemberships = zagent ? zagentRoomMemberships(zagent) : undefined;
   const zagentActiveRoomId = zagent?.activeRoom ?? zagentMemberships?.find((membership) => membership.roomId)?.roomId;
   const zpeerProfileRoomId = zagentActiveRoomId ?? zpeerProfile?.activeRoomId ?? zpeerProfile?.roomId ?? carryoverProfile?.activeRoomId ?? carryoverProfile?.roomId;
@@ -579,7 +593,7 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
       }, { triggerTurn: true, deliverAs: "followUp" });
       return buildZobLiveAckEnvelope(envelope);
     });
-    const peerCard = ensureZpeerFields(repoRoot, {
+    const peerCard = withZpeerLeaseMode(ensureZpeerFields(repoRoot, {
       ...basePeer,
       team: zagent?.team ?? basePeer.team,
       roleId: zagent?.id ?? basePeer.roleId,
@@ -588,58 +602,78 @@ async function startOrRefreshZobLiveRuntime(pi: ExtensionAPI, state: HarnessRunt
       endpoint,
       endpointHash: sha256(endpoint),
       status: "online" as const,
-    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships);
+    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships), useStableTeamAgentLease);
     state.zobLive.server = server;
-    const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_start" });
-    if (leaseClaim.ok) {
+    if (!useStableTeamAgentLease) {
+      releaseZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_adhoc" });
       state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
-      state.zobLive.leaseOwned = true;
-      state.zobLive.leaseStatus = "owned";
+      state.zobLive.leaseOwned = false;
+      state.zobLive.leaseStatus = "unavailable";
       state.zobLive.leaseBlockReason = undefined;
       state.zobLive.lastHeartbeatMs = Date.now();
       scheduleZpeerHeartbeat(pi, state, ctx);
     } else {
-      state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, server);
-      setZpeerLastEvent(state, {
-        kind: "blocked",
-        roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
-        fromAlias: state.zobLive.peerCard.zpeerAlias,
-        status: "lease_blocked",
-        reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
-      });
+      const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_start" });
+      if (leaseClaim.ok) {
+        state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
+        state.zobLive.leaseOwned = true;
+        state.zobLive.leaseStatus = "owned";
+        state.zobLive.leaseBlockReason = undefined;
+        state.zobLive.lastHeartbeatMs = Date.now();
+        scheduleZpeerHeartbeat(pi, state, ctx);
+      } else {
+        state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, server);
+        setZpeerLastEvent(state, {
+          kind: "blocked",
+          roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
+          fromAlias: state.zobLive.peerCard.zpeerAlias,
+          status: "lease_blocked",
+          reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
+        });
+      }
     }
     try { writeZpeerLocalProfileFromPeer(repoRoot, state.zobLive.peerCard, profileId); } catch { /* best-effort reload continuity; live runtime must remain available */ }
   } else {
-    const peerCard = ensureZpeerFields(repoRoot, {
+    const peerCard = withZpeerLeaseMode(ensureZpeerFields(repoRoot, {
       ...state.zobLive.peerCard,
       team: zagent?.team ?? state.zobLive.peerCard.team,
       roleId: zagent?.id ?? state.zobLive.peerCard.roleId,
       agent: zagent?.id ?? state.zobLive.peerCard.agent,
       heartbeatAt: new Date().toISOString(),
       status: "online",
-    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships);
-    const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_refresh" });
-    if (leaseClaim.ok) {
+    }, zpeerProfileRoomId, zpeerProfileAlias, zpeerProfileMemberships), useStableTeamAgentLease);
+    if (!useStableTeamAgentLease) {
+      releaseZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_adhoc" });
       state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
-      state.zobLive.leaseOwned = true;
-      state.zobLive.leaseStatus = "owned";
+      state.zobLive.leaseOwned = false;
+      state.zobLive.leaseStatus = "unavailable";
       state.zobLive.leaseBlockReason = undefined;
       state.zobLive.lastHeartbeatMs = Date.now();
       scheduleZpeerHeartbeat(pi, state, ctx);
-    } else if (state.zobLive.server) {
-      state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, state.zobLive.server);
-      setZpeerLastEvent(state, {
-        kind: "blocked",
-        roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
-        fromAlias: state.zobLive.peerCard.zpeerAlias,
-        status: "lease_blocked",
-        reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
-      });
     } else {
-      state.zobLive.peerCard = writeZobLivePeerCard(repoRoot, { ...peerCard, heartbeatAt: new Date().toISOString(), status: "offline" });
-      state.zobLive.leaseOwned = false;
-      state.zobLive.leaseStatus = "blocked";
-      state.zobLive.leaseBlockReason = "blocked_live_owner";
+      const leaseClaim = await claimZobLiveTeamAgentLease(repoRoot, peerCard, { reason: "runtime_refresh" });
+      if (leaseClaim.ok) {
+        state.zobLive.peerCard = refreshZpeerSelf(repoRoot, peerCard);
+        state.zobLive.leaseOwned = true;
+        state.zobLive.leaseStatus = "owned";
+        state.zobLive.leaseBlockReason = undefined;
+        state.zobLive.lastHeartbeatMs = Date.now();
+        scheduleZpeerHeartbeat(pi, state, ctx);
+      } else if (state.zobLive.server) {
+        state.zobLive.peerCard = await stopLeaseBlockedLocalEndpoint(state, repoRoot, peerCard, state.zobLive.server);
+        setZpeerLastEvent(state, {
+          kind: "blocked",
+          roomId: state.zobLive.peerCard.zpeerActiveRoomId ?? state.zobLive.peerCard.zpeerRoomId,
+          fromAlias: state.zobLive.peerCard.zpeerAlias,
+          status: "lease_blocked",
+          reason: "stable team-agent lease is held by a responsive live endpoint; duplicate local endpoint stopped and peer marked offline",
+        });
+      } else {
+        state.zobLive.peerCard = writeZobLivePeerCard(repoRoot, { ...peerCard, heartbeatAt: new Date().toISOString(), status: "offline" });
+        state.zobLive.leaseOwned = false;
+        state.zobLive.leaseStatus = "blocked";
+        state.zobLive.leaseBlockReason = "blocked_live_owner";
+      }
     }
     try { writeZpeerLocalProfileFromPeer(repoRoot, state.zobLive.peerCard, profileId); } catch { /* best-effort reload continuity; live runtime must remain available */ }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zob-harness",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "type": "module",
   "description": "A governed Agent Factory for Pi: launch communicating agent teams, run tmux-backed factories, validate artifacts, and package repeatable workflows.",
   "license": "MIT",

package/scripts/zpeer-local-e2e-smoke.mjs

@@ -200,6 +200,8 @@ async function main() {
   const gammaEndpoint = join(root, 'gamma.sock');
   const workerOneEndpoint = join(root, 'worker-one.sock');
   const workerTwoEndpoint = join(root, 'worker-two.sock');
+  const adhocOneEndpoint = join(root, 'adhoc-one.sock');
+  const adhocTwoEndpoint = join(root, 'adhoc-two.sock');
   const pendingReplies = new Map();
   const receivedPrompts = [];
   const receivedResponses = [];
@@ -244,6 +246,11 @@ async function main() {
     receivedPrompts.push(incoming);
     return envelope.buildZobLiveAckEnvelope(incoming);
   }));
+  servers.push(await localTransport.bindZobLocalEndpoint(adhocOneEndpoint, async (incoming) => envelope.buildZobLiveAckEnvelope(incoming)));
+  servers.push(await localTransport.bindZobLocalEndpoint(adhocTwoEndpoint, async (incoming) => {
+    receivedPrompts.push(incoming);
+    return envelope.buildZobLiveAckEnvelope(incoming);
+  }));
 
   const oldHeartbeatAt = new Date(Date.now() - 180_000).toISOString();
   let alpha = zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'alpha', roomId: 'room-one', endpoint: alphaEndpoint, endpointHash: hashing.sha256(alphaEndpoint), sha256: hashing.sha256, heartbeatAt: oldHeartbeatAt }), 'room-one', 'alpha');
@@ -279,6 +286,17 @@ async function main() {
     });
   });
 
+  const adhocOne = zpeer.refreshZpeerSelf(repoRoot, { ...zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'adhocone', roomId: 'adhoc-room', endpoint: adhocOneEndpoint, endpointHash: hashing.sha256(adhocOneEndpoint), sha256: hashing.sha256 }), 'adhoc-room', 'adhocone'), zpeerAdhoc: true });
+  const adhocTwo = zpeer.refreshZpeerSelf(repoRoot, { ...zpeer.ensureZpeerFields(repoRoot, makePeer({ alias: 'adhoctwo', roomId: 'adhoc-room', endpoint: adhocTwoEndpoint, endpointHash: hashing.sha256(adhocTwoEndpoint), sha256: hashing.sha256 }), 'adhoc-room', 'adhoctwo'), zpeerAdhoc: true });
+  assert(adhocOne.zpeerAdhoc === true && adhocTwo.zpeerAdhoc === true, 'direct/ad-hoc zpeer peers must carry the ad-hoc marker');
+  const adhocSummary = zpeer.buildZpeerRoomSummary(repoRoot, adhocOne, 'adhoc-room');
+  assert(adhocSummary.peerCount === 2 && adhocSummary.online === 2, `ad-hoc room summary expected 2 online peers even with lease domain present, got ${adhocSummary.online}/${adhocSummary.peerCount}`);
+  assert(adhocSummary.aliases.includes('adhocone') && adhocSummary.aliases.includes('adhoctwo'), 'ad-hoc room summary must include both direct peers');
+  const adhocPromptCountBefore = receivedPrompts.length;
+  const adhocAsync = await zpeer.sendZpeerPrompt(repoRoot, adhocOne, 'adhoctwo', rawPrompt, waitForReply, { mode: 'async' });
+  assert(adhocAsync.status === 'waiting', `ad-hoc same-room send expected waiting after ACK, got ${adhocAsync.status}${adhocAsync.reason ? `: ${adhocAsync.reason}` : ''}`);
+  assert(receivedPrompts.length === adhocPromptCountBefore + 1 && receivedPrompts.at(-1).receiver === 'adhoctwo', 'ad-hoc same-room send must deliver to the target without a stable team-agent lease');
+
   const joinedAlpha = await zpeer.joinZpeerRoom(repoRoot, alpha, 'shared-room', 'sharedalpha', 'bridge');
   assert(joinedAlpha.ok === true, `alpha multi-room join expected ok, got ${joinedAlpha.reason ?? 'not ok'}`);
   alpha = joinedAlpha.peer;

package/scripts/zpeer-static-smoke.mjs

@@ -34,6 +34,7 @@ const files = [
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts',
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer-profile.ts',
   '.pi/extensions/zob-harness/src/domains/coms/coms-v2/transcript-capture.ts',
+  '.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts',
   '.pi/extensions/zob-harness/src/runtime/commands.ts',
   '.pi/extensions/zob-harness/src/runtime/tools-coms.ts',
   '.pi/extensions/zob-harness/src/runtime/events.ts',
@@ -82,7 +83,7 @@ for (const forbidden of ['transientPrompt:', 'transientResponse:', 'prompt:', 'o
 const zpeer = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts'];
 const liveRegistry = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts'];
 const zpeerProfile = contents['.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer-profile.ts'];
-for (const needle of ['networkEnabled: false', 'localOnly: true', 'bodyStored: false', 'sendZobLocalEnvelope', 'taskHash', 'outputHash', 'ZpeerSendMode', 'status: "waiting"', 'status: "reply"', 'zpeerMembershipsForPeer', 'joinZpeerRoom', 'leaveZpeerRoom', 'useZpeerRoom', 'clearZpeerRoom', 'preservedSelf: true', 'roomId?: string', 'buildZpeerPeerRoomSummaries', 'active: membership.roomId === activeRoomId', 'peerRespondsToAliasPing', 'activeAliasCollision', 'zpeer-alias-ping']) {
+for (const needle of ['networkEnabled: false', 'localOnly: true', 'bodyStored: false', 'sendZobLocalEnvelope', 'taskHash', 'outputHash', 'ZpeerSendMode', 'status: "waiting"', 'status: "reply"', 'zpeerMembershipsForPeer', 'joinZpeerRoom', 'leaveZpeerRoom', 'useZpeerRoom', 'clearZpeerRoom', 'preservedSelf: true', 'roomId?: string', 'buildZpeerPeerRoomSummaries', 'active: membership.roomId === activeRoomId', 'peerRespondsToAliasPing', 'activeAliasCollision', 'zpeer-alias-ping', 'zpeerAdhoc']) {
   if (!zpeer.includes(needle)) failures.push(`zpeer missing ${needle}`);
 }
 for (const needle of ['peer-messages.jsonl', 'peer-status.jsonl', 'appendZpeerPeerRecords', 'reasonHash', 'bodyStored: false']) {
@@ -96,7 +97,8 @@ if (!zpeer.includes('const bothPeersAreWorkers = self.roleType === "worker" && t
 if (hardTeamMismatchIndex !== -1 && (roomFirstTopologyIndex === -1 || hardTeamMismatchIndex < roomFirstTopologyIndex)) failures.push('zpeer topology must not hard-block cross-team peers before same-room allowance');
 if (!zpeer.includes('const candidates = peersInRoom(repoRoot, roomId).filter') || !zpeer.includes('if (!selfMembership)') || !zpeer.includes('current peer is observer-only in room')) failures.push('zpeer same-room allowance must preserve room candidate, self membership, and observer guards');
 if (!liveRegistry.includes('readZobLiveRegistryAllProjectsSnapshot') || !liveRegistry.includes('join(projectsDir, entry.name, "agents")')) failures.push('live registry must expose all-project agents room discovery helper');
-for (const needle of ['ZobLiveTeamAgentLease', 'zob.live-team-agent-lease.v1', 'stableLease: true', 'exclusiveBy: "teamId+agentId"', 'claimZobLiveTeamAgentLease', 'leaseRespondsToPing', 'pingZobLocalEndpoint', 'releaseZobLiveTeamAgentLease', 'ownsZobLiveTeamAgentLease', 'sameLeaseOwner', 'retireInactiveZobLiveTeamAgentLeases', 'readLeasesFromDir', 'hasLeaseDomain']) {
+if (!liveRegistry.includes('peer.zpeerAdhoc !== true') || !liveRegistry.includes('mergeLeaseBackedAndAdhocPeers(leaseDirs.flatMap')) failures.push('live registry must merge explicit ad-hoc room peer cards into lease-backed summaries');
+for (const needle of ['ZobLiveTeamAgentLease', 'zob.live-team-agent-lease.v1', 'stableLease: true', 'exclusiveBy: "teamId+agentId"', 'claimZobLiveTeamAgentLease', 'leaseRespondsToPing', 'pingZobLocalEndpoint', 'releaseZobLiveTeamAgentLease', 'ownsZobLiveTeamAgentLease', 'sameLeaseOwner', 'retireInactiveZobLiveTeamAgentLeases', 'readLeasesFromDir', 'hasLeaseDomain', 'mergeLeaseBackedAndAdhocPeers']) {
   if (!liveRegistry.includes(needle)) failures.push(`live registry stable lease support missing ${needle}`);
 }
 if (!zpeer.includes('readZobLiveRegistryAllProjectsSnapshot(repoRoot)')) failures.push('zpeer room discovery must use all-project registry snapshots');
@@ -172,7 +174,7 @@ for (const needle of ['readZpeerNewCarryoverProfile(repoRoot)', 'const carryover
 }
 if (!events.includes('event.source === "extension" && !event.text.trim()') || !events.includes('action: "handled" as const')) failures.push('runtime must handle empty extension follow-ups without continuing the agent');
 if (!events.includes('ZPeer async reply received from @') || !events.includes('{ triggerTurn: true, deliverAs: "followUp" }')) failures.push('runtime must resume an idle agent with a follow-up when an async ZPeer reply arrives');
-for (const needle of ['ZPEER AWARENESS (transient, rebuilt each turn)', 'buildZpeerPeerRoomSummaries(repoRoot, state.zobLive.peerCard)', '- rooms:', 'explicit roomId', 'zpeer_ask with mode=\\"async\\"', 'Passive wait rule', 'stop the turn and remain idle', 'avoid spam', 'Raw ZPeer bodies are transient', 'registerMessageRenderer("zob-zpeer-event"', 'scheduleZpeerHeartbeat', 'clearZpeerHeartbeatTimer', 'refreshZpeerSelf(repoRoot', 'kind: "response_sent"', 'kind: "inbound"']) {
+for (const needle of ['ZPEER AWARENESS (transient, rebuilt each turn)', 'buildZpeerPeerRoomSummaries(repoRoot, state.zobLive.peerCard)', '- rooms:', 'explicit roomId', 'zpeer_ask with mode=\\"async\\"', 'Passive wait rule', 'stop the turn and remain idle', 'avoid spam', 'Raw ZPeer bodies are transient', 'registerMessageRenderer("zob-zpeer-event"', 'scheduleZpeerHeartbeat', 'clearZpeerHeartbeatTimer', 'refreshZpeerSelf(repoRoot', 'kind: "response_sent"', 'kind: "inbound"', 'zpeerStableTeamAgentLeaseRequired', 'withZpeerLeaseMode', 'leaseStatus = "unavailable"', 'runtime_adhoc']) {
   if (!events.includes(needle)) failures.push(`runtime missing zpeer awareness/event support ${needle}`);
 }
 const responseSentBlock = events.match(/setZpeerLastEvent\(state, \{\s*kind: "response_sent"[\s\S]*?customType: "zob-zpeer-event"[\s\S]*?triggerTurn: false[\s\S]*?\}\);/)?.[0] ?? '';
@@ -212,6 +214,11 @@ const goalRuntime = contents['.pi/extensions/zob-harness/src/runtime/goal-runtim
 for (const needle of ['state.zobLive.passivePeerWait?.suppressGoalContinuation === true', 'clearRuntimeGoalContinuationTimer(state)', 'return;']) {
   if (!goalRuntime.includes(needle)) failures.push(`goal runtime missing passive peer continuation suppression ${needle}`);
 }
+
+const childRunner = contents['.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts'];
+for (const needle of ['childModelPattern', 'ctx.model', 'resolveCodexFastModeExtension', 'getAgentDir()', 'codex-fast-mode.ts', 'childCodexFastModeExtension', 'args.push("-e", childCodexFastModeExtension)', 'const model = resolvedModel']) {
+  if (!childRunner.includes(needle)) failures.push(`delegation child runner missing Codex auto/model inheritance support ${needle}`);
+}
 for (const needle of ['updatePassivePeerWaitState(state, result', 'result.status !== "waiting"', 'state.zobLive.passivePeerWait = undefined', 'schema: "zob.passive-peer-wait.v1"', 'source: "zpeer_ask"', 'suppressGoalContinuation: true', 'bodyStored: false', 'localOnly: true', 'networkEnabled: false']) {
   if (!toolsComs.includes(needle)) failures.push(`zpeer_ask missing passive peer wait state handling ${needle}`);
 }