zob-harness 0.1.0 → 0.2.0

package/.pi/extensions/zob-harness/src/model-routing.ts

@@ -64,7 +64,7 @@ function chooseModelClass(input: ModelRoutingDryRunInput): { modelClass: ModelCl
   const risk = normalizeRisk(input.risk);
   const contextTokens = numberOrZero(input.contextTokens);
   const isOracleLike = includesAny(input.taskType, ["oracle", "review", "validate"]) || includesAny(input.outputContract, ["oracle"]);
-  const isImplementationLike = includesAny(input.taskType, ["implement", "factory", "synthesis", "worker"]) || input.mode === "implement" || input.mode === "factory";
+  const isImplementationLike = includesAny(input.taskType, ["implement", "factory", "synthesis", "worker"]) || input.mode === "implement" || input.mode === "factory" || input.mode === "vanilla";
 
   if (contextTokens >= 120_000) {
     reasonCodes.push("context_tokens_high");
@@ -239,7 +239,7 @@ export function validateModelRoutingConfig(repoRoot: string): Record<string, unk
   }
 
   const expectedClasses: ModelClass[] = ["cheap_scout", "balanced_worker", "strong_reasoning", "strong_oracle", "high_context"];
-  const modes: ModeName[] = ["explore", "plan", "implement", "oracle", "factory", "orchestrator"];
+  const modes: ModeName[] = ["explore", "plan", "implement", "oracle", "factory", "orchestrator", "vanilla"];
   const modelClasses = isRecord(parsed?.modelClasses) ? parsed.modelClasses : undefined;
   const defaults = isRecord(parsed?.defaults) ? parsed.defaults : undefined;
   const byMode = isRecord(defaults?.byMode) ? defaults.byMode : undefined;

package/.pi/extensions/zob-harness/src/rules.ts

@@ -8,7 +8,7 @@ import { isRecord } from "./utils/records.js";
 const RULE_PACK_SCHEMA = "zob.rule-pack.v1";
 const RULE_RESOLUTION_SCHEMA = "zob.rule-resolution.v1";
 const RULE_PACK_ORDER = ["always", "project", "runtime", "factory", "orchestration", "prompts", "docs", "sandbox", "oracle"];
-const MODE_NAMES = new Set<ModeName>(["explore", "plan", "implement", "oracle", "factory", "orchestrator"]);
+const MODE_NAMES = new Set<ModeName>(["explore", "plan", "implement", "oracle", "factory", "orchestrator", "vanilla"]);
 const ENFORCEMENT_LEVELS = new Set<RuleEnforcementLevel>(["advisory", "warn", "preflight_fail", "block", "no_ship", "human_approval"]);
 
 const PROFILE_PATHS: Array<{ profile: string; patterns: string[] }> = [

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

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
 
 import { MODE_PROMPTS } from "../constants.js";
@@ -9,12 +9,14 @@ import { buildComputeWorkflowShape } from "../compute-workflow-shape.js";
 import { buildDaemonRuntimeState, buildDaemonTickPlan, type DaemonRuntimeState, type DaemonTickPlan } from "../daemon-runtime.js";
 import { runQueueDaemonTick } from "../queue.js";
 import { buildProjectDnaAgenticPlan, buildProjectDnaQueryResult, buildProjectDnaReadinessAudit } from "../project-dna.js";
+import { formatZagentList, formatZteamList, listZagentManifests, listZteamManifests, loadZagentManifest, loadZteamManifest, normalizeZagentRoomBindings, readZagentPrompt, type ZAgentManifest, type ZAgentRoomBinding, type ZTeamAgentManifest, type ZTeamManifest, type ZTeamMemberManifest } from "../zagents.js";
 import { resolveAdaptiveZmodeEntrypoint, renderAdaptiveZmodeTemplate } from "./adaptive-zmode.js";
 import { handleZcompactCommand } from "./auto-compaction.js";
 import { sha256 } from "../utils/hashing.js";
 import { buildZcommitPlan, formatZcommitPlan, formatZcommitStatus, readZcommitPolicy, runGovernedZcommitAdopt, runGovernedZcommitCommit, runGovernedZcommitPush, type ZcommitAdoptResult, type ZcommitCommandResult, type ZcommitOwnedPathRef, type ZcommitToggleState } from "../git-ops.js";
-import { writeZpeerLocalProfileFromPeer } from "../coms-v2/zpeer-profile.js";
-import { buildZpeerRoomSummary, changeZpeerAlias, changeZpeerRoom, joinZpeerRoom, leaveZpeerRoom, peerAliasInRoom, refreshZpeerSelf, sendZpeerPrompt, useZpeerRoom, zpeerMembershipsForPeer, type ZpeerSendMode } from "../coms-v2/zpeer.js";
+import { clearZpeerNewCarryoverProfile, writeZpeerLocalProfileFromPeer } from "../coms-v2/zpeer-profile.js";
+import { buildZpeerRoomSummary, changeZpeerAlias, changeZpeerRoom, clearZpeerRoom, joinZpeerRoom, leaveZpeerRoom, peerAliasInRoom, refreshZpeerSelf, sendZpeerPrompt, useZpeerRoom, zpeerMembershipsForPeer, type ZpeerSendMode } from "../coms-v2/zpeer.js";
+import { markZpeerNewHardResetPending } from "./events.js";
 import { parseBillableJobIntake, validateBillableJobIntake } from "../goal.js";
 import { handleGoalCommand, handleGoalGateCommand, pauseRuntimeGoalForStop } from "../goal-runtime.js";
 import { formatRuleResolution, resolveRuleProfile } from "../rules.js";
@@ -37,6 +39,11 @@ import { applyMode, renderHarnessWidget } from "./widget.js";
 const COMPUTE_PROFILES = ["auto", "low", "medium", "high", "xhigh", "max"] as const;
 const COMPUTE_DOMAINS = ["generic", "project-dna", "factory", "orchestration"] as const;
 
+function zpeerCommandProfileId(ctx: ExtensionCommandContext): string {
+  const sessionIdentity = ctx.sessionManager.getSessionFile() ?? ctx.sessionManager.getSessionId();
+  return `session-${sha256(sessionIdentity).slice(0, 24)}`;
+}
+
 function zcommitArgumentCompletions(prefix: string): AutocompleteItem[] | null {
   const query = prefix.trim().toLowerCase();
   const items: AutocompleteItem[] = [
@@ -527,6 +534,156 @@ function stopCommandLedgerEntry(input: {
   };
 }
 
+function zagentArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+  const query = prefix.trim().toLowerCase();
+  const ids = listZagentManifests(process.cwd()).map((agent) => agent.manifest.id).filter(Boolean);
+  const items: AutocompleteItem[] = [
+    { value: "list", label: "list", description: "list project-local ZAgents" },
+    ...ids.flatMap((id) => [
+      { value: `show ${id}`, label: `show ${id}`, description: "show manifest metadata" },
+      { value: `use ${id}`, label: `use ${id}`, description: "load ZAgent and apply ZPeer profile" },
+    ]),
+  ];
+  const filtered = query
+    ? items.filter((item) => item.value.toLowerCase().startsWith(query) || item.label.toLowerCase().includes(query) || item.description?.toLowerCase().includes(query))
+    : items;
+  return filtered.length > 0 ? filtered.slice(0, 20) : null;
+}
+
+function zteamArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+  const query = prefix.trim().toLowerCase();
+  const ids = listZteamManifests(process.cwd()).map((team) => team.manifest.id).filter(Boolean);
+  const items: AutocompleteItem[] = [
+    { value: "list", label: "list", description: "list project-local ZTeams" },
+    ...ids.flatMap((id) => [
+      { value: `show ${id}`, label: `show ${id}`, description: "show team manifest metadata" },
+      { value: `launch-plan ${id}`, label: `launch-plan ${id}`, description: "print full-session launch commands" },
+    ]),
+  ];
+  const filtered = query
+    ? items.filter((item) => item.value.toLowerCase().startsWith(query) || item.label.toLowerCase().includes(query) || item.description?.toLowerCase().includes(query))
+    : items;
+  return filtered.length > 0 ? filtered.slice(0, 20) : null;
+}
+
+function zagentLedgerEntry(action: string, input: { id?: string; teamId?: string; status: "ok" | "blocked"; roomIds?: string[]; alias?: string; path?: string; promptRef?: string; promptBody?: string; errors?: string[] }): Record<string, unknown> {
+  return {
+    schema: "zob.zagent-command.v1",
+    action,
+    status: input.status,
+    idHash: input.id ? sha256(input.id) : undefined,
+    teamIdHash: input.teamId ? sha256(input.teamId) : undefined,
+    aliasHash: input.alias ? sha256(input.alias) : undefined,
+    roomIdHashes: (input.roomIds ?? []).map((roomId) => sha256(roomId)),
+    pathHash: input.path ? sha256(input.path) : undefined,
+    promptRefHash: input.promptRef ? sha256(input.promptRef) : undefined,
+    promptHash: input.promptBody ? sha256(input.promptBody) : undefined,
+    errorHashes: (input.errors ?? []).map((error) => sha256(error)),
+    localOnly: true,
+    networkEnabled: false,
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function formatZagentShow(loaded: ReturnType<typeof loadZagentManifest>): string {
+  const rooms = normalizeZagentRoomBindings(loaded.manifest.rooms, loaded.manifest.defaultRoom, loaded.manifest.activeRoom);
+  return [
+    `ZAgent ${loaded.manifest.id}`,
+    `path: ${loaded.path}`,
+    `status: ${loaded.errors.length === 0 ? "ok" : `blocked (${loaded.errors.length} error${loaded.errors.length === 1 ? "" : "s"})`}`,
+    loaded.manifest.description ? `description: ${loaded.manifest.description}` : undefined,
+    loaded.manifest.team ? `team: ${loaded.manifest.team}` : undefined,
+    loaded.manifest.role ? `role: ${loaded.manifest.role}` : undefined,
+    loaded.manifest.alias ? `alias: @${loaded.manifest.alias}` : undefined,
+    rooms.length ? `rooms: ${rooms.map((room) => `${room.id}${room.alias ? `@${room.alias}` : ""}${room.active ? "*" : ""}`).join(", ")}` : "rooms: none",
+    loaded.manifest.promptRef ? `promptRef: ${loaded.manifest.promptRef}` : "promptRef: none",
+    loaded.promptPath ? `promptPath: ${loaded.promptPath}` : undefined,
+    loaded.errors.length ? `errors:\n- ${loaded.errors.join("\n- ")}` : undefined,
+    "safety: project-local, localOnly=true, networkEnabled=false, bodyStored=false",
+  ].filter((line): line is string => Boolean(line)).join("\n");
+}
+
+function formatZteamShow(loaded: ReturnType<typeof loadZteamManifest>): string {
+  const rooms = normalizeZagentRoomBindings(loaded.manifest.rooms, loaded.manifest.defaultRoom, loaded.manifest.activeRoom);
+  const members = zteamMembers(loaded.manifest);
+  return [
+    `ZTeam ${loaded.manifest.id}`,
+    `path: ${loaded.path}`,
+    `status: ${loaded.errors.length === 0 ? "ok" : `blocked (${loaded.errors.length} error${loaded.errors.length === 1 ? "" : "s"})`}`,
+    loaded.manifest.description ? `description: ${loaded.manifest.description}` : undefined,
+    rooms.length ? `rooms: ${rooms.map((room) => `${room.id}${room.active ? "*" : ""}`).join(", ")}` : "rooms: none",
+    `agents: ${members.map((member) => member.id).join(", ") || "none"}`,
+    loaded.errors.length ? `errors:\n- ${loaded.errors.join("\n- ")}` : undefined,
+    "safety: launch-plan only; commands are printed, not spawned",
+  ].filter((line): line is string => Boolean(line)).join("\n");
+}
+
+function normalizeZpeerRole(role: string | undefined): "member" | "bridge" | "observer" {
+  return role === "bridge" || role === "observer" ? role : "member";
+}
+
+async function applyZagentToZpeer(repoRoot: string, peer: NonNullable<HarnessRuntimeState["zobLive"]["peerCard"]>, manifest: ZAgentManifest): Promise<{ ok: true; peer: NonNullable<HarnessRuntimeState["zobLive"]["peerCard"]> } | { ok: false; reason: string; peer: NonNullable<HarnessRuntimeState["zobLive"]["peerCard"]> }> {
+  let current = refreshZpeerSelf(repoRoot, peer);
+  const rooms = normalizeZagentRoomBindings(manifest.rooms, manifest.defaultRoom, manifest.activeRoom);
+  if (rooms.length === 0 && manifest.alias) {
+    const changed = await changeZpeerAlias(repoRoot, current, manifest.alias);
+    if (!changed.ok) return { ok: false, reason: changed.reason, peer: current };
+    current = changed.peer;
+  }
+  for (const room of rooms) {
+    const joined = await joinZpeerRoom(repoRoot, current, room.id, room.alias ?? manifest.alias, normalizeZpeerRole(room.role));
+    if (!joined.ok) return { ok: false, reason: joined.reason, peer: current };
+    current = joined.peer;
+  }
+  const activeRoom = rooms.find((room) => room.active)?.id ?? manifest.activeRoom ?? manifest.defaultRoom;
+  if (activeRoom) {
+    const used = useZpeerRoom(repoRoot, current, activeRoom);
+    if (!used.ok) return { ok: false, reason: used.reason, peer: current };
+    current = used.peer;
+  }
+  return { ok: true, peer: current };
+}
+
+function zteamMemberId(member: ZTeamMemberManifest | ZTeamAgentManifest): string {
+  return "zagentId" in member ? member.zagentId : member.id;
+}
+
+function zteamMembers(team: ZTeamManifest): Array<{ id: string; alias?: string; room?: string; rooms?: ZAgentRoomBinding[]; role?: string; active?: boolean }> {
+  const rawMembers = [...(team.members ?? []), ...(team.agents ?? [])];
+  return rawMembers.map((member) => ({
+    id: zteamMemberId(member),
+    alias: member.alias,
+    room: member.room,
+    rooms: normalizeZagentRoomBindings(member.rooms ?? (member.room ? [member.room] : undefined), team.defaultRoom, member.active ? (member.room ?? team.activeRoom) : undefined),
+    role: member.role,
+    active: member.active,
+  }));
+}
+
+function zteamLaunchPlanText(team: ZTeamManifest): { text: string; roomIds: string[]; agentIds: string[] } {
+  const teamRooms = normalizeZagentRoomBindings(team.rooms, team.defaultRoom, team.activeRoom).map((room) => room.id);
+  const members = zteamMembers(team);
+  const roomIds = [...new Set([...teamRooms, ...members.flatMap((member) => (member.rooms ?? []).map((room) => room.id))])];
+  const agentIds = members.map((member) => member.id);
+  const lines = [
+    `# ZTeam launch-plan: ${team.id}`,
+    "No processes spawned. Copy/paste each command in a separate terminal when approved.",
+    "",
+    ...members.map((member) => {
+      const rooms = (member.rooms ?? []).map((room) => `${room.id}${room.active ? "*" : ""}`).join(", ") || teamRooms.join(", ") || "default";
+      const alias = member.alias ? ` alias=@${member.alias}` : "";
+      return `ZOB_ZAGENT_ID=${member.id} pi    # expected_rooms=${rooms}${alias}`;
+    }),
+    "",
+    `Expected rooms: ${roomIds.join(", ") || "default"}`,
+    "After each session starts, run /zagent use <id> to bind its ZPeer alias/rooms.",
+  ];
+  return { text: lines.join("\n"), roomIds, agentIds };
+}
+
 function delegationArgumentCompletions(state: HarnessRuntimeState, prefix: string): AutocompleteItem[] | null {
   const query = prefix.trim().toLowerCase();
   const items: AutocompleteItem[] = [];
@@ -546,8 +703,43 @@ function delegationArgumentCompletions(state: HarnessRuntimeState, prefix: strin
 }
 
 export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeState): void {
+  // Exact `/new` is handled by Pi before extension input/command hooks. Soft carryover
+  // is therefore written from the `session_shutdown` reason="new" hook in events.ts.
+  // Keep this registration only for `/new hard`, where users need an explicit clean reset.
+  pi.registerCommand("new", {
+    description: "Hard reset helper for ZPeer/ZAgent continuity. Exact /new soft carryover is handled on session_shutdown reason=new.",
+    getArgumentCompletions: (prefix) => {
+      const query = prefix.trim().toLowerCase();
+      const items: AutocompleteItem[] = [
+        { value: "hard", label: "hard", description: "clear ZPeer/ZAgent carryover before starting a clean new session" },
+      ];
+      const filtered = query ? items.filter((item) => item.value.startsWith(query) || item.label.includes(query)) : items;
+      return filtered.length > 0 ? filtered : null;
+    },
+    handler: async (args, ctx) => {
+      const hard = args.trim().split(/\s+/).filter(Boolean)[0]?.toLowerCase() === "hard";
+      if (hard) {
+        markZpeerNewHardResetPending(ctx.cwd);
+        clearZpeerNewCarryoverProfile(ctx.cwd);
+      }
+      pi.appendEntry("zob-znew", {
+        schema: "zob.znew-command.v1",
+        source: "registered_command",
+        action: hard ? "new_hard" : "new_soft_deferred_to_session_shutdown",
+        carryoverWritten: false,
+        carryoverCleared: hard,
+        carryoverDeferredToShutdown: !hard,
+        localOnly: true,
+        networkEnabled: false,
+        bodyStored: false,
+        generatedAt: new Date().toISOString(),
+      });
+      await ctx.newSession();
+    },
+  });
+
   pi.registerCommand("zmode", {
-    description: "Switch ZOB harness mode: explore | plan | implement | oracle | factory | orchestrator. Orchestrator routes to adaptive-chief-vision plan_only defaults.",
+    description: "Switch ZOB harness mode: explore | plan | implement | oracle | factory | orchestrator | vanilla. Orchestrator routes to adaptive-chief-vision plan_only defaults; vanilla restores Pi base-style unrestricted tool access outside ZOB governance.",
     handler: async (args, ctx) => {
       const requestedText = args.trim();
       const adaptiveEntrypoint = resolveAdaptiveZmodeEntrypoint(requestedText);
@@ -645,6 +837,147 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
     }, { triggerTurn: false });
   };
 
+  pi.registerCommand("zagent", {
+    description: "Project-local full-session ZAgents: /zagent list | show <id> | use <id>",
+    getArgumentCompletions: zagentArgumentCompletions,
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const action = (parts[0] ?? "list").toLowerCase();
+      if (action === "list") {
+        const agents = listZagentManifests(ctx.cwd);
+        const roomIds = agents.flatMap((agent) => normalizeZagentRoomBindings(agent.manifest.rooms, agent.manifest.defaultRoom, agent.manifest.activeRoom).map((room) => room.id));
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("list", { status: "ok", roomIds }));
+        renderHarnessWidget(pi, state, ctx);
+        void pi.sendMessage({ customType: "zob-zagent-list", content: formatZagentList(agents), display: true, details: { bodyStored: false } }, { triggerTurn: false });
+        ctx.ui.notify(`zagent list: ${agents.length} project-local manifest${agents.length === 1 ? "" : "s"}`, "info");
+        return;
+      }
+      if (action === "show") {
+        const id = parts[1];
+        if (!id) {
+          ctx.ui.notify("Usage: /zagent show <id>", "warning");
+          return;
+        }
+        const loaded = loadZagentManifest(ctx.cwd, id);
+        const rooms = normalizeZagentRoomBindings(loaded.manifest.rooms, loaded.manifest.defaultRoom, loaded.manifest.activeRoom);
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("show", { id: loaded.manifest.id, status: loaded.errors.length === 0 ? "ok" : "blocked", roomIds: rooms.map((room) => room.id), alias: loaded.manifest.alias, path: loaded.path, promptRef: loaded.manifest.promptRef, errors: loaded.errors }));
+        renderHarnessWidget(pi, state, ctx);
+        void pi.sendMessage({ customType: "zob-zagent-show", content: formatZagentShow(loaded), display: true, details: { id: loaded.manifest.id, bodyStored: false } }, { triggerTurn: false });
+        ctx.ui.notify(`zagent ${loaded.manifest.id}: ${loaded.errors.length === 0 ? "ok" : `blocked (${loaded.errors.length})`}`, loaded.errors.length === 0 ? "info" : "warning");
+        return;
+      }
+      if (action === "use") {
+        const id = parts[1];
+        if (!id) {
+          ctx.ui.notify("Usage: /zagent use <id>", "warning");
+          return;
+        }
+        const loaded = loadZagentManifest(ctx.cwd, id);
+        const prompt = readZagentPrompt(ctx.cwd, loaded.manifest.promptRef);
+        const rooms = normalizeZagentRoomBindings(loaded.manifest.rooms, loaded.manifest.defaultRoom, loaded.manifest.activeRoom);
+        const errors = [...loaded.errors, ...prompt.errors];
+        state.zagent = {
+          id: loaded.manifest.id,
+          team: loaded.manifest.team,
+          role: loaded.manifest.role,
+          alias: loaded.manifest.alias,
+          description: loaded.manifest.description,
+          rooms,
+          activeRoom: rooms.find((room) => room.active)?.id ?? loaded.manifest.activeRoom ?? loaded.manifest.defaultRoom,
+          prompt: prompt.body,
+          promptRef: loaded.manifest.promptRef,
+          path: loaded.path,
+          errors,
+          loadedAt: new Date().toISOString(),
+        };
+        if (errors.length > 0) {
+          pi.appendEntry("zob-zagent", zagentLedgerEntry("use_blocked", { id: loaded.manifest.id, teamId: loaded.manifest.team, status: "blocked", roomIds: rooms.map((room) => room.id), alias: loaded.manifest.alias, path: loaded.path, promptRef: loaded.manifest.promptRef, promptBody: prompt.body, errors }));
+          renderHarnessWidget(pi, state, ctx);
+          ctx.ui.notify(`/zagent use ${id} blocked: ${errors[0]}`, "warning");
+          return;
+        }
+        if (!state.zobLive.peerCard) {
+          const peerErrors = ["current session has not registered a local ZPeer endpoint yet"];
+          state.zagent.errors = peerErrors;
+          pi.appendEntry("zob-zagent", zagentLedgerEntry("use_blocked", { id: loaded.manifest.id, teamId: loaded.manifest.team, status: "blocked", roomIds: rooms.map((room) => room.id), alias: loaded.manifest.alias, path: loaded.path, promptRef: loaded.manifest.promptRef, promptBody: prompt.body, errors: peerErrors }));
+          renderHarnessWidget(pi, state, ctx);
+          ctx.ui.notify(`/zagent use ${id} loaded manifest/prompt but ZPeer is unavailable: ${peerErrors[0]}`, "warning");
+          return;
+        }
+        const applied = await applyZagentToZpeer(ctx.cwd, state.zobLive.peerCard, loaded.manifest);
+        state.zobLive.peerCard = applied.peer;
+        if (!applied.ok) {
+          state.zagent.errors = [applied.reason];
+          pi.appendEntry("zob-zagent", zagentLedgerEntry("use_blocked", { id: loaded.manifest.id, teamId: loaded.manifest.team, status: "blocked", roomIds: rooms.map((room) => room.id), alias: loaded.manifest.alias, path: loaded.path, promptRef: loaded.manifest.promptRef, promptBody: prompt.body, errors: [applied.reason] }));
+          renderHarnessWidget(pi, state, ctx);
+          ctx.ui.notify(`/zagent use ${id} ZPeer apply blocked: ${applied.reason}`, "warning");
+          return;
+        }
+        state.zobLive.peerCard = refreshZpeerSelf(ctx.cwd, applied.peer);
+        state.zobLive.peerCard = {
+          ...state.zobLive.peerCard,
+          team: loaded.manifest.team ?? state.zobLive.peerCard.team,
+          roleId: loaded.manifest.id,
+          agent: loaded.manifest.id,
+        };
+        writeZpeerLocalProfileFromPeer(ctx.cwd, state.zobLive.peerCard, zpeerCommandProfileId(ctx));
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("use", { id: loaded.manifest.id, teamId: loaded.manifest.team, status: "ok", roomIds: zpeerMembershipsForPeer(state.zobLive.peerCard).map((membership) => membership.roomId), alias: state.zobLive.peerCard.zpeerAlias, path: loaded.path, promptRef: loaded.manifest.promptRef, promptBody: prompt.body }));
+        renderHarnessWidget(pi, state, ctx);
+        const active = state.zobLive.peerCard.zpeerRoomId ?? state.zobLive.peerCard.zpeerActiveRoomId ?? "default";
+        ctx.ui.notify(`zagent ${loaded.manifest.id} loaded; ZPeer @${state.zobLive.peerCard.zpeerAlias ?? "?"} active=${active} rooms=${zpeerMembershipsForPeer(state.zobLive.peerCard).length}; promptHash=${prompt.body ? sha256(prompt.body).slice(0, 12) : "none"}`, "info");
+        return;
+      }
+      ctx.ui.notify("Usage: /zagent list | /zagent show <id> | /zagent use <id>", "warning");
+    },
+  });
+
+  pi.registerCommand("zteam", {
+    description: "Project-local ZTeams: /zteam list | show <id> | launch-plan <id>",
+    getArgumentCompletions: zteamArgumentCompletions,
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const action = (parts[0] ?? "list").toLowerCase();
+      if (action === "list") {
+        const teams = listZteamManifests(ctx.cwd);
+        const roomIds = teams.flatMap((team) => normalizeZagentRoomBindings(team.manifest.rooms, team.manifest.defaultRoom, team.manifest.activeRoom).map((room) => room.id));
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("zteam_list", { status: "ok", roomIds }));
+        renderHarnessWidget(pi, state, ctx);
+        void pi.sendMessage({ customType: "zob-zteam-list", content: formatZteamList(teams), display: true, details: { bodyStored: false } }, { triggerTurn: false });
+        ctx.ui.notify(`zteam list: ${teams.length} project-local manifest${teams.length === 1 ? "" : "s"}`, "info");
+        return;
+      }
+      if (action === "show") {
+        const id = parts[1];
+        if (!id) {
+          ctx.ui.notify("Usage: /zteam show <id>", "warning");
+          return;
+        }
+        const loaded = loadZteamManifest(ctx.cwd, id);
+        const rooms = normalizeZagentRoomBindings(loaded.manifest.rooms, loaded.manifest.defaultRoom, loaded.manifest.activeRoom);
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("zteam_show", { teamId: loaded.manifest.id, status: loaded.errors.length === 0 ? "ok" : "blocked", roomIds: rooms.map((room) => room.id), path: loaded.path, errors: loaded.errors }));
+        renderHarnessWidget(pi, state, ctx);
+        void pi.sendMessage({ customType: "zob-zteam-show", content: formatZteamShow(loaded), display: true, details: { id: loaded.manifest.id, bodyStored: false } }, { triggerTurn: false });
+        ctx.ui.notify(`zteam ${loaded.manifest.id}: ${loaded.errors.length === 0 ? "ok" : `blocked (${loaded.errors.length})`}`, loaded.errors.length === 0 ? "info" : "warning");
+        return;
+      }
+      if (action === "launch-plan") {
+        const id = parts[1];
+        if (!id) {
+          ctx.ui.notify("Usage: /zteam launch-plan <id>", "warning");
+          return;
+        }
+        const loaded = loadZteamManifest(ctx.cwd, id);
+        const plan = zteamLaunchPlanText(loaded.manifest);
+        pi.appendEntry("zob-zagent", zagentLedgerEntry("zteam_launch_plan", { teamId: loaded.manifest.id, status: loaded.errors.length === 0 ? "ok" : "blocked", roomIds: plan.roomIds, path: loaded.path, errors: loaded.errors }));
+        renderHarnessWidget(pi, state, ctx);
+        void pi.sendMessage({ customType: "zob-zteam-launch-plan", content: loaded.errors.length ? `${plan.text}\n\nBlocked manifest errors:\n- ${loaded.errors.join("\n- ")}` : plan.text, display: true, details: { id: loaded.manifest.id, agentIdHashes: plan.agentIds.map((agentId) => sha256(agentId)), roomIdHashes: plan.roomIds.map((roomId) => sha256(roomId)), bodyStored: false } }, { triggerTurn: false });
+        ctx.ui.notify(`zteam ${loaded.manifest.id} launch-plan printed; spawn count=0; expectedRooms=${plan.roomIds.join(",") || "default"}`, loaded.errors.length === 0 ? "info" : "warning");
+        return;
+      }
+      ctx.ui.notify("Usage: /zteam list | /zteam show <id> | /zteam launch-plan <id>", "warning");
+    },
+  });
+
   pi.registerCommand("zpeer", {
     description: "Room-scoped local peer sessions: /zpeer, /zpeer name <alias>, /zpeer room <roomId>, /zpeer @alias <prompt>",
     handler: async (args, ctx) => {
@@ -684,27 +1017,28 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
       }
       const parts = trimmed.split(/\s+/);
       const verb = parts[0]?.toLowerCase();
+      const zpeerProfileId = zpeerCommandProfileId(ctx);
       if (verb === "name") {
-        const result = changeZpeerAlias(ctx.cwd, self, parts[1] ?? "");
+        const result = await changeZpeerAlias(ctx.cwd, self, parts[1] ?? "");
         if (!result.ok) {
           ctx.ui.notify(`/zpeer name blocked: ${result.reason}`, "warning");
           return;
         }
         state.zobLive.peerCard = result.peer;
-        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer);
+        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer, zpeerProfileId);
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "name", aliasHash: sha256(result.peer.zpeerAlias ?? ""), roomIdHash: sha256(result.peer.zpeerRoomId ?? "default"), localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         renderHarnessWidget(pi, state, ctx);
         ctx.ui.notify(`zpeer alias set to @${result.peer.zpeerAlias}`, "info");
         return;
       }
       if (verb === "room") {
-        const result = changeZpeerRoom(ctx.cwd, self, parts[1] ?? "");
+        const result = await changeZpeerRoom(ctx.cwd, self, parts[1] ?? "");
         if (!result.ok) {
           ctx.ui.notify(`/zpeer room blocked: ${result.reason}`, "warning");
           return;
         }
         state.zobLive.peerCard = result.peer;
-        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer);
+        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer, zpeerProfileId);
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "room", aliasHash: sha256(result.peer.zpeerAlias ?? ""), roomIdHash: sha256(result.peer.zpeerRoomId ?? "default"), membershipCount: zpeerMembershipsForPeer(result.peer).length, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         renderHarnessWidget(pi, state, ctx);
         ctx.ui.notify(`zpeer room set to ${result.peer.zpeerRoomId} as @${result.peer.zpeerAlias}`, "info");
@@ -718,17 +1052,28 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
         ctx.ui.notify(`zpeer active=${self.zpeerRoomId ?? "default"} rooms=${summaries.map((summary) => `${summary.roomId}(${summary.online}/${summary.peerCount})`).join(", ") || "none"}`, "info");
         return;
       }
+      if (verb === "clear") {
+        const result = clearZpeerRoom(ctx.cwd, self, parts[1] ?? self.zpeerRoomId ?? "default");
+        if (!result.ok) {
+          ctx.ui.notify(`/zpeer clear blocked: ${result.reason}`, "warning");
+          return;
+        }
+        pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "clear", roomIdHash: sha256(result.roomId), clearedCount: result.cleared, preservedSelf: result.preservedSelf, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
+        renderHarnessWidget(pi, state, ctx);
+        ctx.ui.notify(`zpeer room ${result.roomId} cleared: ${result.cleared} other peer${result.cleared === 1 ? "" : "s"} marked offline/removed; current session preserved`, "info");
+        return;
+      }
       if (verb === "join") {
         const asIndex = parts.indexOf("as");
         const alias = asIndex >= 0 ? parts[asIndex + 1] : undefined;
         const role = parts.includes("--bridge") ? "bridge" : parts.includes("--observer") ? "observer" : "member";
-        const result = joinZpeerRoom(ctx.cwd, self, parts[1] ?? "", alias, role);
+        const result = await joinZpeerRoom(ctx.cwd, self, parts[1] ?? "", alias, role);
         if (!result.ok) {
           ctx.ui.notify(`/zpeer join blocked: ${result.reason}`, "warning");
           return;
         }
         state.zobLive.peerCard = result.peer;
-        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer);
+        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer, zpeerProfileId);
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "join", aliasHash: sha256(alias ?? result.peer.zpeerAlias ?? ""), roomIdHash: sha256(parts[1] ?? "default"), membershipCount: zpeerMembershipsForPeer(result.peer).length, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         renderHarnessWidget(pi, state, ctx);
         ctx.ui.notify(`zpeer joined ${parts[1]} (${role}); active=${result.peer.zpeerRoomId}`, "info");
@@ -741,7 +1086,7 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
           return;
         }
         state.zobLive.peerCard = result.peer;
-        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer);
+        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer, zpeerProfileId);
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "use", aliasHash: sha256(result.peer.zpeerAlias ?? ""), roomIdHash: sha256(result.peer.zpeerRoomId ?? "default"), membershipCount: zpeerMembershipsForPeer(result.peer).length, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         renderHarnessWidget(pi, state, ctx);
         ctx.ui.notify(`zpeer active room set to ${result.peer.zpeerRoomId} as @${result.peer.zpeerAlias}`, "info");
@@ -754,7 +1099,7 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
           return;
         }
         state.zobLive.peerCard = result.peer;
-        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer);
+        writeZpeerLocalProfileFromPeer(ctx.cwd, result.peer, zpeerProfileId);
         pi.appendEntry("zob-zpeer", { schema: "zob.zpeer-command.v1", action: "leave", roomIdHash: sha256(parts[1] ?? "default"), membershipCount: zpeerMembershipsForPeer(result.peer).length, localOnly: true, networkEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, generatedAt: new Date().toISOString() });
         renderHarnessWidget(pi, state, ctx);
         ctx.ui.notify(`zpeer left ${parts[1]}; active=${result.peer.zpeerRoomId}`, "info");
@@ -818,11 +1163,12 @@ export function registerHarnessCommands(pi: ExtensionAPI, state: HarnessRuntimeS
           ctx.ui.notify(`zpeer ${result.roomId ?? eventRoomId} @${targetAlias} reply · response displayed transiently · outputHash=${result.outputHash ?? "present"}`, "info");
         } else {
           const ok = result.status === "reply" || result.status === "completed" || result.status === "waiting" || result.status === "delivered";
-          ctx.ui.notify(ok ? `zpeer ${result.roomId ?? eventRoomId} @${targetAlias} ${result.status}${result.outputHash ? ` outputHash=${result.outputHash}` : ""}` : `zpeer ${result.roomId ?? eventRoomId} @${targetAlias} ${result.status}: ${result.reason ?? "see metadata"}`, ok ? "info" : "warning");
+          const passiveWaitSuffix = result.status === "waiting" ? " · idle/passive wait; no follow-up turn queued" : "";
+          ctx.ui.notify(ok ? `zpeer ${result.roomId ?? eventRoomId} @${targetAlias} ${result.status}${result.outputHash ? ` outputHash=${result.outputHash}` : ""}${passiveWaitSuffix}` : `zpeer ${result.roomId ?? eventRoomId} @${targetAlias} ${result.status}: ${result.reason ?? "see metadata"}`, ok ? "info" : "warning");
         }
         return;
       }
-      ctx.ui.notify("Usage: /zpeer | /zpeer rooms | /zpeer join <roomId> [as <alias>] | /zpeer use <roomId> | /zpeer leave <roomId> | /zpeer @alias <prompt> | /zpeer in <roomId> @alias <prompt>", "warning");
+      ctx.ui.notify("Usage: /zpeer | /zpeer rooms | /zpeer clear <roomId> | /zpeer join <roomId> [as <alias>] | /zpeer use <roomId> | /zpeer leave <roomId> | /zpeer @alias <prompt> | /zpeer in <roomId> @alias <prompt>", "warning");
     },
   });
 

package/.pi/extensions/zob-harness/src/runtime/delegation-overlay.ts

@@ -62,6 +62,7 @@ export class DelegationOverlayComponent implements Component {
   private listScroll = 0;
   private logScroll = 0;
   private sortIndex = 0;
+  private activePane: "list" | "feed" = "list";
   private cachedTranscriptKey?: string;
   private cachedTranscriptLines: string[] = [];
   private followTail = true;
@@ -151,12 +152,24 @@ export class DelegationOverlayComponent implements Component {
       this.helpVisible = !this.helpVisible;
       return;
     }
+    if (matchesKey(data, "left")) {
+      this.activePane = "list";
+      return;
+    }
+    if (matchesKey(data, "right")) {
+      this.activePane = "feed";
+      return;
+    }
 
     const rows = this.rows();
     const selectable = rows.filter((row) => row.kind === "run" && row.run);
     const currentIndex = Math.max(0, selectable.findIndex((row) => row.id === this.selectedRunId));
 
     if (matchesKey(data, "up")) {
+      if (this.activePane === "feed") {
+        this.scrollTranscript("up");
+        return;
+      }
       if (selectable.length === 0) return;
       const next = selectable[Math.max(0, currentIndex - 1)];
       this.selectedRunId = next?.id;
@@ -165,6 +178,10 @@ export class DelegationOverlayComponent implements Component {
       this.ensureSelectionOnNextRender = true;
       this.ensureSelectedVisible(rows);
     } else if (matchesKey(data, "down")) {
+      if (this.activePane === "feed") {
+        this.scrollTranscript("down");
+        return;
+      }
       if (selectable.length === 0) return;
       const next = selectable[Math.min(selectable.length - 1, currentIndex + 1)];
       this.selectedRunId = next?.id;
@@ -227,12 +244,13 @@ export class DelegationOverlayComponent implements Component {
     const rightRule = "─".repeat(Math.max(0, inner - titleWidth - leftRule.length));
     const lines: string[] = [th.fg("border", `╭${leftRule}`) + th.fg("accent", title) + th.fg("border", `${rightRule}╮`)];
 
-    const headerLeft = `${th.fg("accent", "Agents")} ${th.fg("muted", delegateCloseButton())}`;
+    const headerLeft = `${th.fg(this.activePane === "list" ? "accent" : "muted", this.activePane === "list" ? "▶ Agents" : "  Agents")} ${th.fg("muted", delegateCloseButton())}`;
     const selectedBadge = delegationSignalBadge(selected);
     const selectedBadgeText = formatDelegationSignalBadge(selectedBadge);
-    const headerRight = selected
+    const selectedTitle = selected
       ? `${th.fg(statusColor(selected.status), `${statusIcon(selected.status)} ${selected.agent}`)}${selectedBadgeText ? ` ${th.fg(delegationSignalColor(selectedBadge), selectedBadgeText)}` : ""}${formatDelegationModelLabel(selected) ? ` ${th.fg("muted", `(${formatDelegationModelLabel(selected)})`)}` : ""} ${th.fg("dim", formatDuration(delegationDurationMs(selected)))} ${th.fg("accent", formatDelegationCostLabel(selected))} ${th.fg("muted", formatDelegationContextLabel(selected))}`
       : th.fg("warning", "No delegation selected");
+    const headerRight = `${th.fg(this.activePane === "feed" ? "accent" : "muted", this.activePane === "feed" ? "▶ Feed" : "  Feed")} ${selectedTitle}`;
     lines.push(this.row(padToWidth(headerLeft, listWidth) + th.fg("dim", "│") + padToWidth(headerRight, logWidth), inner));
     lines.push(th.fg("border", `├${"─".repeat(listWidth)}┼${"─".repeat(logWidth)}┤`));
 
@@ -249,10 +267,10 @@ export class DelegationOverlayComponent implements Component {
 
     const filterInfo = this.filter || this.filterEditing ? ` · filter=${this.filterEditing ? ">" : ""}${this.filter || "<type>"}` : "";
     const helpInfo = this.helpVisible
-      ? " · help: / filter · ? hide help · Esc clears filter/closes · ↑↓ select · [] list · PgUp/PgDn feed · s sort · r refresh"
+      ? " · help: / filter · ? hide help · Esc clears filter/closes · ←→ focus list/feed · ↑↓ select/scroll · [] list · PgUp/PgDn feed · s sort · r refresh"
       : " · / filter · ? help";
     const noMatchInfo = noMatch ? ` · ${noMatch}` : "";
-    const scrollInfo = `${rows.length} rows${filterInfo}${noMatchInfo} · list ${Math.min(this.listScroll + 1, rows.length || 1)}/${Math.max(1, rows.length)} · feed ${Math.min(this.logScroll + 1, transcript.length || 1)}/${Math.max(1, transcript.length)} · wheel over list/feed · click agent · [close]/Esc · ↑↓ select · [] list · PgUp/PgDn feed · End live-tail · s sort · r refresh${helpInfo}`;
+    const scrollInfo = `${rows.length} rows${filterInfo}${noMatchInfo} · focus ${this.activePane} · list ${Math.min(this.listScroll + 1, rows.length || 1)}/${Math.max(1, rows.length)} · feed ${Math.min(this.logScroll + 1, transcript.length || 1)}/${Math.max(1, transcript.length)} · wheel over list/feed · click agent · [close]/Esc · ←→ focus · ↑↓ select/scroll · [] list · PgUp/PgDn feed · End live-tail · s sort · r refresh${helpInfo}`;
     lines.push(th.fg("border", `├${"─".repeat(inner)}┤`));
     lines.push(this.row(th.fg("dim", truncateToWidth(scrollInfo, inner, "…")), inner));
     lines.push(th.fg("border", `╰${"─".repeat(inner)}╯`));