zob-harness 0.1.1 → 0.2.0

package/.pi/capabilities/zob-public-runtime-capabilities.json

@@ -1520,6 +1520,40 @@
       ],
       "noShipNotes": "Local-only multi-room-scoped peer UX with active-room compatibility; transient prompt/response over local_socket, persisted command/mission metadata is hash/body-free."
     },
+    {
+      "name": "zagent",
+      "family": "zagent",
+      "modes": [
+        "all"
+      ],
+      "skillRefs": [
+        ".pi/skills/zob-zagent-creator/SKILL.md",
+        ".pi/skills/zob-coms-v2-live/SKILL.md",
+        ".pi/skills/zob-harness/SKILL.md"
+      ],
+      "docRefs": [
+        "AGENTS.md",
+        ".pi/skills/zob-zagent-creator/SKILL.md"
+      ],
+      "noShipNotes": "Project-local ZAgent definition UX for .pi/zagents/ only. ZAgents are full-session Pi/ZPeer identities tied to live coordination, not delegate subagents; launch-plan is plan/metadata only and must not spawn processes. Persisted command metadata must remain hash/body-free."
+    },
+    {
+      "name": "zteam",
+      "family": "zagent",
+      "modes": [
+        "all"
+      ],
+      "skillRefs": [
+        ".pi/skills/zob-zagent-creator/SKILL.md",
+        ".pi/skills/zob-coms-v2-live/SKILL.md",
+        ".pi/skills/zob-harness/SKILL.md"
+      ],
+      "docRefs": [
+        "AGENTS.md",
+        ".pi/skills/zob-zagent-creator/SKILL.md"
+      ],
+      "noShipNotes": "Project-local ZTeam bundle UX for .pi/zteams/ only. ZTeam members are full-session Pi/ZPeer identities tied to live coordination, not delegate subagents; launch-plan is plan/metadata only and must not spawn processes. Persisted command metadata must remain hash/body-free."
+    },
     {
       "name": "rules_status",
       "family": "safety",

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

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
 import { isRecord } from "../utils/records.js";
@@ -34,6 +34,50 @@ function peerPath(repoRoot: string, peer: Pick<ZobLivePeerCard, "roleId" | "sess
   return join(dir, `${safeFileStem(`${peer.roleId}-${peer.sessionHash.slice(0, 12)}`)}.json`);
 }
 
+function peerPathForProjectId(projectId: string, peer: Pick<ZobLivePeerCard, "roleId" | "sessionHash">): string {
+  return join(registryRoot().path, "projects", safeFileStem(projectId), "agents", `${safeFileStem(`${peer.roleId}-${peer.sessionHash.slice(0, 12)}`)}.json`);
+}
+
+function readPeerCardsFromAgentsDir(dir: string, nowMs: number, teamName?: string): ZobLivePeerCard[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((entry) => entry.endsWith(".json"))
+    .map((entry) => {
+      try {
+        return parsePeerCard(JSON.parse(readFileSync(join(dir, entry), "utf8")) as unknown);
+      } catch {
+        return undefined;
+      }
+    })
+    .filter((peer): peer is ZobLivePeerCard => Boolean(peer))
+    .filter((peer) => !teamName || peer.team === teamName)
+    .map((peer) => ({ ...peer, status: derivePeerStatus(peer, nowMs) }));
+}
+
+function allProjectAgentsDirs(): string[] {
+  const root = registryRoot();
+  const projectsDir = join(root.path, "projects");
+  if (!existsSync(projectsDir)) return [];
+  return readdirSync(projectsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => join(projectsDir, entry.name, "agents"));
+}
+
+function buildSnapshot(projectId: string, kind: "user_runtime" | "env_override", peers: ZobLivePeerCard[], teamName?: string): ZobLiveRegistrySnapshot {
+  const counts: Record<ZobLivePeerStatus, number> = { online: 0, stale: 0, offline: 0 };
+  for (const peer of peers) counts[peer.status] += 1;
+  return {
+    schema: "zob.live-registry-snapshot.v1",
+    projectId,
+    registry: kind,
+    team: teamName,
+    generatedAt: new Date().toISOString(),
+    peers,
+    counts,
+    bodyStored: false,
+  };
+}
+
 function parsePeerCard(value: unknown): ZobLivePeerCard | undefined {
   if (!isRecord(value) || value.schema !== "zob.live-peer-card.v1") return undefined;
   if (hasForbiddenPersistedKey(value) || value.bodyStored !== false) return undefined;
@@ -59,6 +103,15 @@ export function writeZobLivePeerCard(repoRoot: string, peer: ZobLivePeerCard): Z
   return peer;
 }
 
+export function writeZobLivePeerCardToProjectId(peer: ZobLivePeerCard): ZobLivePeerCard {
+  if (hasForbiddenPersistedKey(peer)) throw new Error("Refusing to persist ZOB live peer card with forbidden body-like keys");
+  if (peer.bodyStored !== false) throw new Error("ZOB live peer card bodyStored must be false");
+  const filePath = peerPathForProjectId(peer.projectId, peer);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(peer, null, 2)}\n`, "utf8");
+  return peer;
+}
+
 export function registerCurrentZobLivePeer(repoRoot: string, teamName = "zob-core"): ZobLivePeerCard | undefined {
   const policy = readZobComsV2Policy(repoRoot);
   if (!zobComsRegistryEnabled(policy)) return undefined;
@@ -83,31 +136,12 @@ export function unregisterCurrentZobLivePeer(repoRoot: string, teamName = "zob-c
 
 export function readZobLiveRegistrySnapshot(repoRoot: string, teamName?: string): ZobLiveRegistrySnapshot {
   const { dir, projectId, kind } = projectAgentsDir(repoRoot);
+  return buildSnapshot(projectId, kind, readPeerCardsFromAgentsDir(dir, Date.now(), teamName), teamName);
+}
+
+export function readZobLiveRegistryAllProjectsSnapshot(repoRoot: string, teamName?: string): ZobLiveRegistrySnapshot {
+  const { projectId, kind } = projectAgentsDir(repoRoot);
   const nowMs = Date.now();
-  const peers = existsSync(dir)
-    ? readdirSync(dir)
-      .filter((entry) => entry.endsWith(".json"))
-      .map((entry) => {
-        try {
-          return parsePeerCard(JSON.parse(readFileSync(join(dir, entry), "utf8")) as unknown);
-        } catch {
-          return undefined;
-        }
-      })
-      .filter((peer): peer is ZobLivePeerCard => Boolean(peer))
-      .filter((peer) => !teamName || peer.team === teamName)
-      .map((peer) => ({ ...peer, status: derivePeerStatus(peer, nowMs) }))
-    : [];
-  const counts: Record<ZobLivePeerStatus, number> = { online: 0, stale: 0, offline: 0 };
-  for (const peer of peers) counts[peer.status] += 1;
-  return {
-    schema: "zob.live-registry-snapshot.v1",
-    projectId,
-    registry: kind,
-    team: teamName,
-    generatedAt: new Date().toISOString(),
-    peers,
-    counts,
-    bodyStored: false,
-  };
+  const peers = allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
+  return buildSnapshot(projectId, kind, peers, teamName);
 }

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -9,6 +9,8 @@ import { isRecord } from "../utils/records.js";
 import { safeFileStem } from "../utils/paths.js";
 
 const PROFILE_SCHEMA = "zob.zpeer-local-profile.v1";
+const NEW_CARRYOVER_SCHEMA = "zob.zpeer-new-carryover.v1";
+const DEFAULT_NEW_CARRYOVER_TTL_MS = 30 * 60 * 1000;
 const FORBIDDEN_PROFILE_KEYS = new Set(["body", "task", "prompt", "output", "content", "message", "response", "rationale", "text", "diff", "patch"]);
 
 export interface ZpeerLocalProfile {
@@ -26,6 +28,31 @@ export interface ZpeerLocalProfile {
   bodyStored: false;
 }
 
+export interface ZpeerNewCarryoverProfile {
+  schema: typeof NEW_CARRYOVER_SCHEMA;
+  projectId: string;
+  alias?: string;
+  roomId?: string;
+  activeRoomId?: string;
+  memberships?: ZpeerRoomMembership[];
+  zagentId?: string;
+  createdAt: string;
+  updatedAt: string;
+  expiresAt: string;
+  localOnly: true;
+  networkEnabled: false;
+  bodyStored: false;
+}
+
+export interface ZpeerNewCarryoverInput {
+  alias?: string;
+  roomId?: string;
+  activeRoomId?: string;
+  memberships?: ZpeerRoomMembership[];
+  zagentId?: string;
+  ttlMs?: number;
+}
+
 function registryRoot(): string {
   const override = process.env.ZOB_COMS_REGISTRY_ROOT;
   if (override && override.trim().length > 0) return override;
@@ -59,11 +86,17 @@ function derivedSessionSeed(repoRoot: string): string | undefined {
 export function resolveZpeerProfileId(repoRoot: string): string {
   const explicit = firstEnvValue(["ZOB_ZPEER_PROFILE_ID", "ZPEER_PROFILE"]);
   if (explicit) return safeFileStem(`explicit-${explicit.value}`).slice(0, 80) || `explicit-${sha256(explicit.value).slice(0, 16)}`;
-  const comsSession = firstEnvValue(["ZOB_COMS_SESSION_ID"]);
-  if (comsSession) return safeFileStem(`coms-${comsSession.value}`).slice(0, 80) || `coms-${sha256(comsSession.value).slice(0, 16)}`;
   const terminalSeed = derivedSessionSeed(repoRoot);
   if (terminalSeed) return `terminal-${sha256(terminalSeed).slice(0, 20)}`;
-  return `process-${sha256(`${repoRoot}:${process.pid}:${Date.now()}`).slice(0, 20)}`;
+  const comsSession = firstEnvValue(["ZOB_COMS_SESSION_ID"]);
+  if (comsSession) return safeFileStem(`coms-${comsSession.value}`).slice(0, 80) || `coms-${sha256(comsSession.value).slice(0, 16)}`;
+  const role = firstEnvValue(["ZOB_COMS_ROLE_ID"]);
+  const roleId = role?.value ?? "zob-orchestrator";
+  return `role-${safeFileStem(roleId).slice(0, 40) || sha256(roleId).slice(0, 16)}`;
+}
+
+export function zpeerProfileIdIsSharedFallback(profileId = resolveZpeerProfileId("")): boolean {
+  return profileId.startsWith("role-");
 }
 
 function zpeerProfileDir(repoRoot: string): { dir: string; projectId: string } {
@@ -76,12 +109,32 @@ export function zpeerProfilePath(repoRoot: string, profileId = resolveZpeerProfi
   return join(dir, `${safeFileStem(sha256(profileId).slice(0, 32))}.json`);
 }
 
+function zpeerNewCarryoverProfilePath(repoRoot: string): string {
+  const { dir } = zpeerProfileDir(repoRoot);
+  return join(dir, "new-carryover.json");
+}
+
 function hasForbiddenProfileKey(value: unknown): boolean {
   if (!value || typeof value !== "object") return false;
   if (Array.isArray(value)) return value.some(hasForbiddenProfileKey);
   return Object.entries(value).some(([key, child]) => FORBIDDEN_PROFILE_KEYS.has(key) || hasForbiddenProfileKey(child));
 }
 
+function validZpeerMemberships(value: unknown): value is ZpeerRoomMembership[] {
+  if (!Array.isArray(value)) return false;
+  for (const membership of value) {
+    if (!isRecord(membership)) return false;
+    if (hasForbiddenProfileKey(membership)) return false;
+    if (typeof membership.roomId !== "string" || typeof membership.alias !== "string" || typeof membership.role !== "string") return false;
+    if (typeof membership.joinedAt !== "string" || membership.localOnly !== true || membership.networkEnabled !== false || membership.bodyStored !== false) return false;
+  }
+  return true;
+}
+
+function validIsoDate(value: unknown): value is string {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+
 function parseZpeerLocalProfile(value: unknown, repoRoot: string): ZpeerLocalProfile | undefined {
   if (!isRecord(value) || value.schema !== PROFILE_SCHEMA) return undefined;
   if (hasForbiddenProfileKey(value) || value.bodyStored !== false || value.localOnly !== true || value.networkEnabled !== false) return undefined;
@@ -89,18 +142,25 @@ function parseZpeerLocalProfile(value: unknown, repoRoot: string): ZpeerLocalPro
   if (value.alias !== undefined && typeof value.alias !== "string") return undefined;
   if (value.roomId !== undefined && typeof value.roomId !== "string") return undefined;
   if (value.activeRoomId !== undefined && typeof value.activeRoomId !== "string") return undefined;
-  if (value.memberships !== undefined) {
-    if (!Array.isArray(value.memberships)) return undefined;
-    for (const membership of value.memberships) {
-      if (!isRecord(membership)) return undefined;
-      if (typeof membership.roomId !== "string" || typeof membership.alias !== "string" || typeof membership.role !== "string") return undefined;
-      if (typeof membership.joinedAt !== "string" || membership.localOnly !== true || membership.networkEnabled !== false || membership.bodyStored !== false) return undefined;
-    }
-  }
+  if (value.memberships !== undefined && !validZpeerMemberships(value.memberships)) return undefined;
   if (typeof value.createdAt !== "string" || typeof value.updatedAt !== "string") return undefined;
   return value as unknown as ZpeerLocalProfile;
 }
 
+function parseZpeerNewCarryoverProfile(value: unknown, repoRoot: string, nowMs = Date.now()): ZpeerNewCarryoverProfile | undefined {
+  if (!isRecord(value) || value.schema !== NEW_CARRYOVER_SCHEMA) return undefined;
+  if (hasForbiddenProfileKey(value) || value.bodyStored !== false || value.localOnly !== true || value.networkEnabled !== false) return undefined;
+  if (value.projectId !== buildZobComsProjectId(repoRoot)) return undefined;
+  if (value.alias !== undefined && typeof value.alias !== "string") return undefined;
+  if (value.roomId !== undefined && typeof value.roomId !== "string") return undefined;
+  if (value.activeRoomId !== undefined && typeof value.activeRoomId !== "string") return undefined;
+  if (value.zagentId !== undefined && typeof value.zagentId !== "string") return undefined;
+  if (value.memberships !== undefined && !validZpeerMemberships(value.memberships)) return undefined;
+  if (!validIsoDate(value.createdAt) || !validIsoDate(value.updatedAt) || !validIsoDate(value.expiresAt)) return undefined;
+  if (Date.parse(value.expiresAt) <= nowMs) return undefined;
+  return value as unknown as ZpeerNewCarryoverProfile;
+}
+
 export function readZpeerLocalProfile(repoRoot: string, profileId = resolveZpeerProfileId(repoRoot)): ZpeerLocalProfile | undefined {
   const path = zpeerProfilePath(repoRoot, profileId);
   if (!existsSync(path)) return undefined;
@@ -115,14 +175,15 @@ export function writeZpeerLocalProfile(repoRoot: string, input: { alias?: string
   const { dir, projectId } = zpeerProfileDir(repoRoot);
   const existing = readZpeerLocalProfile(repoRoot, profileId);
   const now = new Date().toISOString();
+  const sharedFallback = zpeerProfileIdIsSharedFallback(profileId);
   const profile: ZpeerLocalProfile = {
     schema: PROFILE_SCHEMA,
     profileId,
     projectId,
-    alias: input.alias ?? existing?.alias,
+    alias: sharedFallback ? undefined : input.alias ?? existing?.alias,
     roomId: input.roomId ?? existing?.roomId,
     activeRoomId: input.activeRoomId ?? input.roomId ?? existing?.activeRoomId,
-    memberships: input.memberships ?? existing?.memberships,
+    memberships: sharedFallback ? undefined : input.memberships ?? existing?.memberships,
     createdAt: existing?.createdAt ?? now,
     updatedAt: now,
     localOnly: true,
@@ -135,6 +196,68 @@ export function writeZpeerLocalProfile(repoRoot: string, input: { alias?: string
   return profile;
 }
 
-export function writeZpeerLocalProfileFromPeer(repoRoot: string, peer: Pick<ZobLivePeerCard, "zpeerAlias" | "zpeerRoomId" | "zpeerActiveRoomId" | "zpeerMemberships">, profileId = resolveZpeerProfileId(repoRoot)): ZpeerLocalProfile {
-  return writeZpeerLocalProfile(repoRoot, { alias: peer.zpeerAlias, roomId: peer.zpeerRoomId, activeRoomId: peer.zpeerActiveRoomId, memberships: peer.zpeerMemberships }, profileId);
+export function readZpeerNewCarryoverProfile(repoRoot: string): ZpeerNewCarryoverProfile | undefined {
+  const path = zpeerNewCarryoverProfilePath(repoRoot);
+  if (!existsSync(path)) return undefined;
+  try {
+    const profile = parseZpeerNewCarryoverProfile(JSON.parse(readFileSync(path, "utf8")) as unknown, repoRoot);
+    if (!profile) clearZpeerNewCarryoverProfile(repoRoot);
+    return profile;
+  } catch {
+    return undefined;
+  }
+}
+
+export function writeZpeerNewCarryoverProfile(repoRoot: string, input: ZpeerNewCarryoverInput): ZpeerNewCarryoverProfile {
+  if (hasForbiddenProfileKey(input)) throw new Error("Refusing to persist ZPeer /new carryover profile with forbidden body-like keys");
+  if (input.memberships !== undefined && !validZpeerMemberships(input.memberships)) throw new Error("Refusing to persist ZPeer /new carryover profile with invalid memberships");
+  const { dir, projectId } = zpeerProfileDir(repoRoot);
+  const existing = readZpeerNewCarryoverProfile(repoRoot);
+  const nowMs = Date.now();
+  const now = new Date(nowMs).toISOString();
+  const ttlMs = input.ttlMs !== undefined && Number.isFinite(input.ttlMs) && input.ttlMs > 0 ? input.ttlMs : DEFAULT_NEW_CARRYOVER_TTL_MS;
+  const profile: ZpeerNewCarryoverProfile = {
+    schema: NEW_CARRYOVER_SCHEMA,
+    projectId,
+    alias: input.alias ?? existing?.alias,
+    roomId: input.roomId ?? existing?.roomId,
+    activeRoomId: input.activeRoomId ?? input.roomId ?? existing?.activeRoomId,
+    memberships: input.memberships ?? existing?.memberships,
+    zagentId: input.zagentId ?? existing?.zagentId,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    expiresAt: new Date(nowMs + ttlMs).toISOString(),
+    localOnly: true,
+    networkEnabled: false,
+    bodyStored: false,
+  };
+  if (hasForbiddenProfileKey(profile)) throw new Error("Refusing to persist ZPeer /new carryover profile with forbidden body-like keys");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(zpeerNewCarryoverProfilePath(repoRoot), `${JSON.stringify(profile, null, 2)}\n`, "utf8");
+  return profile;
+}
+
+export function clearZpeerNewCarryoverProfile(repoRoot: string): void {
+  const path = zpeerNewCarryoverProfilePath(repoRoot);
+  if (existsSync(path)) unlinkSync(path);
+}
+
+function generatedAliasForPeer(peer: Pick<ZobLivePeerCard, "roleId" | "sessionHash">): string | undefined {
+  const roleAlias = `${peer.roleId}-${peer.sessionHash.slice(0, 6)}`;
+  if (/^[a-zA-Z][a-zA-Z0-9_-]{1,31}$/.test(roleAlias)) return roleAlias;
+  return `peer-${peer.sessionHash.slice(0, 8)}`;
+}
+
+function activeMembershipAlias(peer: Pick<ZobLivePeerCard, "zpeerRoomId" | "zpeerActiveRoomId" | "zpeerMemberships">): string | undefined {
+  const activeRoomId = peer.zpeerActiveRoomId ?? peer.zpeerRoomId;
+  return peer.zpeerMemberships?.find((membership) => membership.roomId === activeRoomId)?.alias;
+}
+
+export function writeZpeerLocalProfileFromPeer(repoRoot: string, peer: Pick<ZobLivePeerCard, "roleId" | "sessionHash" | "zpeerAlias" | "zpeerRoomId" | "zpeerActiveRoomId" | "zpeerMemberships">, profileId = resolveZpeerProfileId(repoRoot)): ZpeerLocalProfile {
+  const existing = readZpeerLocalProfile(repoRoot, profileId);
+  const generatedAlias = generatedAliasForPeer(peer);
+  const membershipAlias = activeMembershipAlias(peer);
+  const candidateAlias = membershipAlias ?? peer.zpeerAlias;
+  const alias = candidateAlias && candidateAlias !== generatedAlias ? candidateAlias : existing?.alias ?? candidateAlias;
+  return writeZpeerLocalProfile(repoRoot, { alias, roomId: peer.zpeerRoomId, activeRoomId: peer.zpeerActiveRoomId, memberships: peer.zpeerMemberships }, profileId);
 }

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

@@ -4,10 +4,11 @@ import { join } from "node:path";
 import { buildZobComsProjectId } from "./identity.js";
 import { buildZobLiveEnvelope } from "./envelope.js";
 import { sendZobLocalEnvelope } from "./local-transport.js";
-import { readZobLiveRegistrySnapshot, writeZobLivePeerCard } from "./registry.js";
+import { readZobLiveRegistryAllProjectsSnapshot, writeZobLivePeerCard, writeZobLivePeerCardToProjectId } from "./registry.js";
 import type { ZobLivePeerCard, ZobLivePeerStatus, ZpeerRoomMembership, ZpeerRoomMembershipRole } from "./types.js";
 import { validateZobComsEdge } from "../topology/coms.js";
 import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+import { loadZteamManifest, zteamAllowsZpeerContact } from "../zagents.js";
 import { sha256 } from "../utils/hashing.js";
 
 const DEFAULT_ROOM_ID = "default";
@@ -180,6 +181,34 @@ function zpeerReachableStatus(peer: ZobLivePeerCard): ZobLivePeerStatus {
   return "offline";
 }
 
+async function peerRespondsToAliasPing(peer: ZobLivePeerCard): Promise<boolean> {
+  if (zpeerReachableStatus(peer) !== "online") return false;
+  try {
+    const response = await sendZobLocalEnvelope(peer.endpoint, {
+      schema: "zob.live-envelope.v1",
+      type: "ping",
+      msgId: `zpeer-alias-ping:${Date.now()}`,
+      hops: 0,
+      timestamp: new Date().toISOString(),
+      bodyStored: false,
+    }, { timeoutMs: 1_000 });
+    return response.type === "pong" || response.type === "ack";
+  } catch {
+    return false;
+  }
+}
+
+async function activeAliasCollision(repoRoot: string, self: ZobLivePeerCard, roomId: string, alias: string): Promise<ZpeerRoomPeer | undefined> {
+  for (const entry of peersInRoom(repoRoot, roomId)) {
+    if (entry.peer.sessionHash === self.sessionHash || entry.membership.alias !== alias) continue;
+    if (await peerRespondsToAliasPing(entry.peer)) return entry;
+    if (zpeerReachableStatus(entry.peer) === "online") {
+      try { writeZobLivePeerCard(repoRoot, { ...entry.peer, heartbeatAt: new Date().toISOString(), status: "offline" }); } catch { /* best-effort stale alias release */ }
+    }
+  }
+  return undefined;
+}
+
 export function ensureZpeerFields(repoRoot: string, peer: ZobLivePeerCard, roomId?: string, alias?: string, restoredMemberships?: ZpeerRoomMembership[]): ZobLivePeerCard {
   const hasRestoredMemberships = Boolean(restoredMemberships && restoredMemberships.length > 0);
   const baseMemberships = hasRestoredMemberships
@@ -204,25 +233,27 @@ export function refreshZpeerSelf(repoRoot: string, peer: ZobLivePeerCard, roomId
   return writeZobLivePeerCard(repoRoot, { ...ensured, heartbeatAt: new Date().toISOString(), status: "online" });
 }
 
-function peersInRoom(repoRoot: string, roomId: string): ZpeerRoomPeer[] {
-  const projectId = buildZobComsProjectId(repoRoot);
-  return readZobLiveRegistrySnapshot(repoRoot).peers
-    .filter((peer) => peer.projectId === projectId)
+type ZobLiveRegistrySnapshotValue = ReturnType<typeof readZobLiveRegistryAllProjectsSnapshot>;
+
+function peersInRoomFromSnapshot(snapshot: ZobLiveRegistrySnapshotValue, roomId: string): ZpeerRoomPeer[] {
+  return snapshot.peers
     .flatMap((peer) => zpeerMembershipsForPeer(peer)
       .filter((membership) => membership.roomId === roomId)
       .map((membership) => ({ peer, membership })));
 }
 
-export function buildZpeerRoomSummary(repoRoot: string, self?: ZobLivePeerCard, requestedRoomId?: string): ZpeerRoomSummary {
-  const roomId = safeZpeerRoomId(requestedRoomId) ?? (self ? activeZpeerRoomId(self) : DEFAULT_ROOM_ID);
-  const peers = peersInRoom(repoRoot, roomId);
+function peersInRoom(repoRoot: string, roomId: string): ZpeerRoomPeer[] {
+  return peersInRoomFromSnapshot(readZobLiveRegistryAllProjectsSnapshot(repoRoot), roomId);
+}
+
+function buildZpeerRoomSummaryFromPeers(projectId: string, self: ZobLivePeerCard | undefined, roomId: string, peers: ZpeerRoomPeer[]): ZpeerRoomSummary {
   const counts: Record<ZobLivePeerStatus, number> = { online: 0, stale: 0, offline: 0 };
   const aliases = peers.map((entry) => entry.membership.alias).sort();
   for (const entry of peers) counts[zpeerReachableStatus(entry.peer)] += 1;
   const duplicateAliases = aliases.filter((alias, index) => aliases.indexOf(alias) !== index).filter((alias, index, all) => all.indexOf(alias) === index);
   return {
     schema: "zob.zpeer-room-summary.v1",
-    projectId: buildZobComsProjectId(repoRoot),
+    projectId,
     roomId,
     selfAlias: self ? peerAliasInRoom(self, roomId) : undefined,
     peerCount: peers.length,
@@ -238,10 +269,17 @@ export function buildZpeerRoomSummary(repoRoot: string, self?: ZobLivePeerCard,
   };
 }
 
+export function buildZpeerRoomSummary(repoRoot: string, self?: ZobLivePeerCard, requestedRoomId?: string): ZpeerRoomSummary {
+  const snapshot = readZobLiveRegistryAllProjectsSnapshot(repoRoot);
+  const roomId = safeZpeerRoomId(requestedRoomId) ?? (self ? activeZpeerRoomId(self) : DEFAULT_ROOM_ID);
+  return buildZpeerRoomSummaryFromPeers(snapshot.projectId, self, roomId, peersInRoomFromSnapshot(snapshot, roomId));
+}
+
 export function buildZpeerPeerRoomSummaries(repoRoot: string, self: ZobLivePeerCard): ZpeerPeerRoomSummary[] {
+  const snapshot = readZobLiveRegistryAllProjectsSnapshot(repoRoot);
   const activeRoomId = activeZpeerRoomId(self);
   return zpeerMembershipsForPeer(self).map((membership) => ({
-    ...buildZpeerRoomSummary(repoRoot, self, membership.roomId),
+    ...buildZpeerRoomSummaryFromPeers(snapshot.projectId, self, membership.roomId, peersInRoomFromSnapshot(snapshot, membership.roomId)),
     active: membership.roomId === activeRoomId,
   })).sort((left, right) => {
     if (left.active !== right.active) return left.active ? -1 : 1;
@@ -249,26 +287,26 @@ export function buildZpeerPeerRoomSummaries(repoRoot: string, self: ZobLivePeerC
   });
 }
 
-export function changeZpeerAlias(repoRoot: string, self: ZobLivePeerCard, requestedAlias: string, requestedRoomId?: string): { ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string } {
+export async function changeZpeerAlias(repoRoot: string, self: ZobLivePeerCard, requestedAlias: string, requestedRoomId?: string): Promise<{ ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string }> {
   const alias = safeZpeerAlias(requestedAlias);
   if (!alias) return { ok: false, reason: "alias must match [a-zA-Z][a-zA-Z0-9_-]{1,31}" };
   const roomId = safeZpeerRoomId(requestedRoomId) ?? activeZpeerRoomId(self);
   const memberships = zpeerMembershipsForPeer(self);
   const current = memberships.find((membership) => membership.roomId === roomId);
   if (!current) return { ok: false, reason: `current peer is not a member of room '${roomId}'` };
-  const collision = peersInRoom(repoRoot, roomId).find((entry) => entry.peer.sessionHash !== self.sessionHash && entry.membership.alias === alias && entry.peer.status !== "offline");
-  if (collision) return { ok: false, reason: `alias '${alias}' is already used in room '${roomId}'` };
+  const collision = await activeAliasCollision(repoRoot, self, roomId, alias);
+  if (collision) return { ok: false, reason: `alias '${alias}' is already used by a live peer in room '${roomId}'` };
   return { ok: true, peer: refreshZpeerSelf(repoRoot, withZpeerMembershipState(repoRoot, self, upsertMembership(memberships, { ...current, alias }), activeZpeerRoomId(self))) };
 }
 
-export function joinZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedRoom: string, requestedAlias?: string, role: ZpeerRoomMembershipRole = "member"): { ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string } {
+export async function joinZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedRoom: string, requestedAlias?: string, role: ZpeerRoomMembershipRole = "member"): Promise<{ ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string }> {
   const roomId = safeZpeerRoomId(requestedRoom);
   if (!roomId) return { ok: false, reason: "room must match [a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}" };
   const memberships = zpeerMembershipsForPeer(self);
   const existing = memberships.find((membership) => membership.roomId === roomId);
   const alias = safeZpeerAlias(requestedAlias ?? existing?.alias ?? self.zpeerAlias) ?? generatedZpeerAlias(self);
-  const collision = peersInRoom(repoRoot, roomId).find((entry) => entry.peer.sessionHash !== self.sessionHash && entry.membership.alias === alias && entry.peer.status !== "offline");
-  if (collision) return { ok: false, reason: `alias '${alias}' already exists in target room '${roomId}'; rename first or use 'as <alias>'` };
+  const collision = await activeAliasCollision(repoRoot, self, roomId, alias);
+  if (collision) return { ok: false, reason: `alias '${alias}' already exists on a live peer in target room '${roomId}'; rename first or use 'as <alias>'` };
   const next = buildMembership({ roomId, alias, role, joinedAt: existing?.joinedAt ?? new Date().toISOString() });
   return { ok: true, peer: refreshZpeerSelf(repoRoot, withZpeerMembershipState(repoRoot, self, upsertMembership(memberships, next), activeZpeerRoomId(self))) };
 }
@@ -292,12 +330,37 @@ export function useZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedR
   return { ok: true, peer: refreshZpeerSelf(repoRoot, withZpeerMembershipState(repoRoot, self, memberships, roomId)) };
 }
 
-export function changeZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedRoom: string): { ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string } {
+export function clearZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedRoom: string): { ok: true; roomId: string; cleared: number; preservedSelf: true } | { ok: false; reason: string } {
+  const roomId = safeZpeerRoomId(requestedRoom);
+  if (!roomId) return { ok: false, reason: "room must match [a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}" };
+  let cleared = 0;
+  for (const entry of peersInRoom(repoRoot, roomId)) {
+    if (entry.peer.sessionHash === self.sessionHash) continue;
+    const remaining = zpeerMembershipsForPeer(entry.peer).filter((membership) => membership.roomId !== roomId);
+    const fallbackRoomId = `cleared-${entry.peer.sessionHash.slice(0, 8)}`;
+    const fallbackAlias = safeZpeerAlias(entry.peer.zpeerAlias) ?? generatedZpeerAlias(entry.peer);
+    const nextMemberships = remaining.length > 0 ? remaining : [buildMembership({ roomId: fallbackRoomId, alias: fallbackAlias, role: "observer", joinedAt: new Date().toISOString() })];
+    const active = nextMemberships[0];
+    writeZobLivePeerCardToProjectId({
+      ...entry.peer,
+      heartbeatAt: new Date().toISOString(),
+      status: "offline",
+      zpeerRoomId: active.roomId,
+      zpeerActiveRoomId: active.roomId,
+      zpeerAlias: active.alias,
+      zpeerMemberships: nextMemberships,
+    });
+    cleared += 1;
+  }
+  return { ok: true, roomId, cleared, preservedSelf: true };
+}
+
+export async function changeZpeerRoom(repoRoot: string, self: ZobLivePeerCard, requestedRoom: string): Promise<{ ok: true; peer: ZobLivePeerCard } | { ok: false; reason: string }> {
   const roomId = safeZpeerRoomId(requestedRoom);
   if (!roomId) return { ok: false, reason: "room must match [a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}" };
   const memberships = zpeerMembershipsForPeer(self);
   if (!memberships.some((membership) => membership.roomId === roomId)) {
-    const joined = joinZpeerRoom(repoRoot, self, roomId, self.zpeerAlias ?? generatedZpeerAlias(self));
+    const joined = await joinZpeerRoom(repoRoot, self, roomId, self.zpeerAlias ?? generatedZpeerAlias(self));
     if (!joined.ok) return joined;
     return useZpeerRoom(repoRoot, joined.peer, roomId);
   }
@@ -345,8 +408,12 @@ function appendZpeerPeerRecords(repoRoot: string, record: {
   appendHashOnlyZpeerJsonl(repoRoot, "peer-status.jsonl", { ...base, schema: "zob.zpeer-peer-status.v1" });
 }
 
-function validateZpeerTopology(repoRoot: string, self: ZobLivePeerCard, target: ZobLivePeerCard): string | undefined {
+function validateZpeerTopology(repoRoot: string, self: ZobLivePeerCard, target: ZobLivePeerCard, roomId: string, selfAlias?: string, targetAlias?: string): string | undefined {
   if (self.roleId === target.roleId && self.roleType === "orchestrator" && target.roleType === "orchestrator") return undefined;
+  const selfInRequestedRoom = isPeerInZpeerRoom(self, roomId);
+  const targetInRequestedRoom = isPeerInZpeerRoom(target, roomId);
+  const bothPeersAreWorkers = self.roleType === "worker" && target.roleType === "worker";
+  if (selfInRequestedRoom && targetInRequestedRoom && !bothPeersAreWorkers) return undefined;
   const teamName = self.team || target.team || "zob-core";
   if (target.team !== teamName) return "zpeer topology blocked: peers are in different teams";
   let topologyRoot = repoRoot;
@@ -355,11 +422,19 @@ function validateZpeerTopology(repoRoot: string, self: ZobLivePeerCard, target:
     topologyRoot = process.cwd();
     loaded = loadTeamDefinition(topologyRoot, teamName);
   }
-  if (!loaded.definition) return `zpeer topology blocked: ${loaded.errors.join("; ")}`;
-  const definitionErrors = validateTeamDefinition(topologyRoot, loaded.definition);
-  if (definitionErrors.length > 0) return `zpeer topology blocked: ${definitionErrors.join("; ")}`;
-  const edgeErrors = validateZobComsEdge(loaded.definition, self.roleId, target.roleId);
-  if (edgeErrors.length > 0) return `zpeer topology blocked: ${edgeErrors.join("; ")}`;
+  if (loaded.definition) {
+    const definitionErrors = validateTeamDefinition(topologyRoot, loaded.definition);
+    if (definitionErrors.length > 0) return `zpeer topology blocked: ${definitionErrors.join("; ")}`;
+    const edgeErrors = validateZobComsEdge(loaded.definition, self.roleId, target.roleId);
+    if (edgeErrors.length === 0) return undefined;
+    if (!edgeErrors.some((error) => error.startsWith("Unknown coms sender") || error.startsWith("Unknown coms receiver"))) return `zpeer topology blocked: ${edgeErrors.join("; ")}`;
+  }
+
+  if (!self.team || self.team !== target.team) return "zpeer topology blocked: peers are not in the same zteam";
+  const zteam = loadZteamManifest(repoRoot, self.team);
+  if (zteam.errors.length > 0) return `zpeer topology blocked: ${loaded.errors.join("; ") || "legacy topology rejected ZAgent role ids"}; zteam fallback blocked: ${zteam.errors.join("; ")}`;
+  if (!zteamAllowsZpeerContact(zteam.manifest, self.roleId, roomId, selfAlias)) return `zpeer topology blocked: zteam '${self.team}' does not allow ${self.roleId} in room '${roomId}'`;
+  if (!zteamAllowsZpeerContact(zteam.manifest, target.roleId, roomId, targetAlias)) return `zpeer topology blocked: zteam '${target.team}' does not allow ${target.roleId} in room '${roomId}'`;
   return undefined;
 }
 
@@ -400,7 +475,7 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
   const target = candidates[0];
   const targetReachableStatus = zpeerReachableStatus(target.peer);
   if (targetReachableStatus !== "online") return finish("attempt", { status: "blocked", reason: `peer @${targetAlias} is ${targetReachableStatus}`, targetAlias, taskHash, bodyStored: false }, 1);
-  const topologyBlocker = validateZpeerTopology(repoRoot, self, target.peer);
+  const topologyBlocker = validateZpeerTopology(repoRoot, self, target.peer, roomId, senderAlias, target.membership.alias);
   if (topologyBlocker) return finish("attempt", { status: "blocked", reason: topologyBlocker, targetAlias, taskHash, bodyStored: false }, 1);
   if (target.peer.transport !== "local_socket" || target.peer.endpoint.startsWith("pending-") || target.peer.endpoint === "observe-only") return finish("attempt", { status: "blocked", reason: `peer @${targetAlias} is not reachable by local_socket`, targetAlias, taskHash, bodyStored: false }, 1);
   if (self.transport !== "local_socket" || !self.endpoint || self.endpoint.startsWith("pending-") || self.endpoint === "observe-only") return finish("attempt", { status: "blocked", reason: "current session has no local_socket reply endpoint", targetAlias, taskHash, bodyStored: false }, 1);

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

@@ -560,6 +560,10 @@ export function resumeRuntimeGoal(goal: RuntimeGoal, requestedAdditionalTurns?:
 export function queueRuntimeGoalContinuation(pi: ExtensionAPI, state: HarnessRuntimeState, ctx: ExtensionContext, options: { userVisible?: boolean; retryMs?: number } = {}): void {
   const goal = state.runtimeGoal;
   if (!canContinue(goal)) return;
+  if (state.zobLive.passivePeerWait?.suppressGoalContinuation === true) {
+    clearRuntimeGoalContinuationTimer(state);
+    return;
+  }
   const humanDecision = pauseIfHumanDecisionRequired(pi, state, goal);
   if (humanDecision) {
     ctx.ui.notify(`ZOB /goal paused: ${goal.oracle.blockerSummary}`, "warning");