zob-harness 0.11.0 → 0.12.0

package/.pi/extensions/zob-harness/index.ts

@@ -52,6 +52,8 @@ export type { PlanLaunchStatus, PlanTodoCanonicalItem, PlanTodoCanonicalManifest
 export { ZOB_COMPACTION_CONTINUITY_CONTRACT, ZOB_TOOL_ROUTING_CONTRACT } from "./src/core/constants.js";
 export { ZOB_COMPACTION_DETAILS_SCHEMA, ZOB_COMPACTION_ENTRY_TYPE, ZOB_COMPACTION_HARD_CAP_TOKENS, ZOB_COMPACTION_LEDGER_SCHEMA, ZOB_COMPACTION_SUMMARY_SCHEMA, ZOB_COMPACTION_TARGET_TOKENS, buildDeterministicZobCompactionResult, buildDeterministicZobCompactionSummary, buildZobCompactionDetails, buildZobCompactionInstructions, buildZobCompactionLedgerEntry, buildZobCompactionStateCapsule, withZobCompactionDetails, zobCompactionBodyFreeViolations } from "./src/runtime/compaction-policy.js";
 export type { ZobCompactionDetails, ZobCompactionFileRefsInput, ZobCompactionInstructionInput, ZobCompactionLedgerEntry, ZobCompactionStateCapsule } from "./src/runtime/compaction-policy.js";
+export { assistantMessageHasVisibleOutput, createStopRestoreCandidate, findStopRestoreUserEntryId, markStopRestoreAssistantMessage, markStopRestoreRestored, markStopRestoreToolVisible, shouldRestoreStopPrompt } from "./src/runtime/stop-restore.js";
+export type { StopRestoreCandidate, StopRestoreCandidateInput, StopRestoreDecision, StopRestoreDecisionInput, StopRestoreRewindResult } from "./src/runtime/stop-restore.js";
 export { isAdaptiveZmodeAlias, renderAdaptiveZmodeTemplate, resolveAdaptiveZmodeEntrypoint, validateAdaptiveZmodeEntrypoint } from "./src/runtime/adaptive-zmode.js";
 export type { AdaptiveZmodeAlias, AdaptiveZmodeEntrypoint } from "./src/runtime/adaptive-zmode.js";
 export {

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

@@ -15,6 +15,7 @@ import type { HarnessRuntimeState } from "../state.js";
 import { renderHarnessWidget } from "../widget.js";
 import type { HarnessCommandContext } from "./types.js";
 import { daemonInputFromState, daemonRuntimeLedgerEntry, stopDaemonLoop } from "./daemon.js";
+import { findStopRestoreUserEntryId, markStopRestoreRestored, shouldRestoreStopPrompt, type StopRestoreDecision, type StopRestoreRewindResult } from "../stop-restore.js";
 
 function abortForegroundWork(ctx: HarnessCommandContext): boolean {
   const idle = typeof ctx.isIdle === "function" ? ctx.isIdle() : true;
@@ -52,6 +53,8 @@ function stopCommandLedgerEntry(input: {
   daemonWasRunning: boolean;
   runtimeGoalPaused: boolean;
   runtimeGoalId?: string;
+  stopRestoreDecision?: StopRestoreDecision;
+  stopRestoreRewind?: StopRestoreRewindResult;
 }): Record<string, unknown> {
   return {
     schema: "zob.stop-command.v1",
@@ -63,6 +66,14 @@ function stopCommandLedgerEntry(input: {
     daemonWasRunning: input.daemonWasRunning,
     runtimeGoalPaused: input.runtimeGoalPaused,
     runtimeGoalId: input.runtimeGoalId,
+    editorPromptRestored: input.stopRestoreDecision?.restore === true,
+    editorPromptRestoreReason: input.stopRestoreDecision?.reason,
+    editorPromptHash: input.stopRestoreDecision?.promptHash,
+    assistantOutputObservedBeforeStop: input.stopRestoreDecision?.assistantOutputObserved,
+    editorPromptRewindAttempted: input.stopRestoreRewind?.attempted,
+    editorPromptRewindSucceeded: input.stopRestoreRewind?.succeeded,
+    editorPromptRewindReason: input.stopRestoreRewind?.reason,
+    editorPromptRewindTargetId: input.stopRestoreRewind?.targetEntryId,
     bodyStored: false,
     promptBodiesStored: false,
     outputBodiesStored: false,
@@ -70,6 +81,36 @@ function stopCommandLedgerEntry(input: {
   };
 }
 
+async function restoreStopPromptAndRewind(ctx: HarnessCommandContext, state: HarnessRuntimeState, decision: StopRestoreDecision): Promise<StopRestoreRewindResult> {
+  if (!decision.restore || !decision.promptText) {
+    return { attempted: false, succeeded: false, reason: decision.reason };
+  }
+  try {
+    if (typeof ctx.waitForIdle === "function") await ctx.waitForIdle();
+  } catch {
+    ctx.ui.setEditorText(decision.promptText);
+    markStopRestoreRestored(state.stopRestoreCandidate);
+    return { attempted: true, succeeded: false, reason: "wait_for_idle_failed" };
+  }
+  const targetEntryId = findStopRestoreUserEntryId(state.stopRestoreCandidate, ctx.sessionManager.getEntries());
+  if (!targetEntryId) {
+    ctx.ui.setEditorText(decision.promptText);
+    markStopRestoreRestored(state.stopRestoreCandidate);
+    return { attempted: true, succeeded: false, reason: "user_entry_not_found" };
+  }
+  try {
+    const navigation = await ctx.navigateTree(targetEntryId, { summarize: false });
+    ctx.ui.setEditorText(decision.promptText);
+    markStopRestoreRestored(state.stopRestoreCandidate);
+    if (navigation.cancelled) return { attempted: true, succeeded: false, reason: "navigate_cancelled", targetEntryId };
+    return { attempted: true, succeeded: true, reason: "rewound_to_prompt_checkpoint", targetEntryId };
+  } catch {
+    ctx.ui.setEditorText(decision.promptText);
+    markStopRestoreRestored(state.stopRestoreCandidate);
+    return { attempted: true, succeeded: false, reason: "navigate_failed", targetEntryId };
+  }
+}
+
 export function registerNewCommand(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.
@@ -116,11 +157,17 @@ export function registerStopCommand(pi: ExtensionAPI, state: HarnessRuntimeState
       const daemonWasRunning = state.daemon.loop.status === "running";
       const runtimeGoalId = state.runtimeGoal?.goalId;
       const foregroundAbortRequested = abortForegroundWork(ctx);
+      const stopRestoreDecision = shouldRestoreStopPrompt(state.stopRestoreCandidate, {
+        foregroundAbortRequested,
+        idleBeforeStop,
+        pendingMessagesBeforeStop,
+      });
       const background = abortBackgroundDelegations(state);
       stopDaemonLoop(state, "slash_stop");
       const pausedGoal = pauseRuntimeGoalForStop(pi, state, "stopped by /stop; use /goal resume to continue");
       const daemonState = buildDaemonRuntimeState(daemonInputFromState(state));
       state.daemon.lastStatus = daemonState;
+      const stopRestoreRewind = await restoreStopPromptAndRewind(ctx, state, stopRestoreDecision);
       pi.appendEntry("zob-daemon-runtime", daemonRuntimeLedgerEntry(daemonState));
       pi.appendEntry("zob-stop", stopCommandLedgerEntry({
         foregroundAbortRequested,
@@ -131,9 +178,11 @@ export function registerStopCommand(pi: ExtensionAPI, state: HarnessRuntimeState
         daemonWasRunning,
         runtimeGoalPaused: Boolean(pausedGoal && pausedGoal.goalId === runtimeGoalId && pausedGoal.status === "paused"),
         runtimeGoalId,
+        stopRestoreDecision,
+        stopRestoreRewind,
       }));
       renderHarnessWidget(pi, state, ctx);
-      ctx.ui.notify(`ZOB stop: foreground=${foregroundAbortRequested ? "aborted" : "idle"} background_aborted=${background.abortedCount} daemon=${daemonWasRunning ? "stopped" : "already_stopped"} goal=${pausedGoal?.status ?? "none"}`, "warning");
+      ctx.ui.notify(`ZOB stop: foreground=${foregroundAbortRequested ? "aborted" : "idle"} input=${stopRestoreDecision.restore ? "restored" : "unchanged"} rewind=${stopRestoreRewind.succeeded ? "yes" : "no"} background_aborted=${background.abortedCount} daemon=${daemonWasRunning ? "stopped" : "already_stopped"} goal=${pausedGoal?.status ?? "none"}`, "warning");
     },
   });
 }

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

@@ -3,7 +3,7 @@ import { resolve, sep } from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Markdown, truncateToWidth, visibleWidth, type MarkdownTheme } from "@earendil-works/pi-tui";
 
-import { delegationDurationMs, delegationSignalBadge, delegationSignalColor, formatDelegationContextLabel, formatDelegationCostLabel, formatDelegationModelLabel, formatDelegationSignalBadge, formatDuration, statusIcon, type DelegationRunView } from "./delegation-monitor.js";
+import { delegationDurationMs, delegationSignalBadge, delegationSignalColor, formatDelegationContextLabel, formatDelegationCostLabel, formatDelegationCwdLabel, formatDelegationModelLabel, formatDelegationSignalBadge, formatDelegationWorkspaceLabel, formatDuration, statusIcon, type DelegationRunView } from "./delegation-monitor.js";
 import { formatActivityDuration, formatActivitySummary, readDelegationActivitySnapshot } from "./delegation-activity.js";
 import { sanitizeDelegationText } from "./delegation-markdown.js";
 import { isRecord } from "../core/utils/records.js";
@@ -109,6 +109,7 @@ export function delegationFeedFingerprint(run: DelegationRunView | undefined, re
     run.usage?.contextTokens ?? "",
     (run.gateErrors ?? []).join(";"),
     run.model ?? "",
+    run.cwd ?? "",
   ].join("|");
 }
 
@@ -395,7 +396,10 @@ export function renderDelegationFeedLines(run: DelegationRunView | undefined, re
   const signalBadge = delegationSignalBadge(run);
   const signalText = formatDelegationSignalBadge(signalBadge);
   const modelLabel = formatDelegationModelLabel(run);
-  lines.push(theme.fg("dim", `${statusIcon(run.status)} ${run.agent}${signalText ? ` · ${theme.fg(delegationSignalColor(signalBadge), signalText)}` : ""}${modelLabel ? ` · ${theme.fg("muted", `(${modelLabel})`)}` : ""} · ${run.status}${run.failureKind ? ` · ${run.failureKind}` : ""} · ${formatDuration(delegationDurationMs(run))} · ${formatDelegationCostLabel(run)} · ${formatDelegationContextLabel(run)}`));
+  const cwdLabel = formatDelegationCwdLabel(run, repoRoot);
+  const workspaceLabel = formatDelegationWorkspaceLabel(run, repoRoot, Math.max(24, safeWidth - 2));
+  lines.push(theme.fg("dim", `${statusIcon(run.status)} ${run.agent}${signalText ? ` · ${theme.fg(delegationSignalColor(signalBadge), signalText)}` : ""}${modelLabel ? ` · ${theme.fg("muted", `(${modelLabel})`)}` : ""}${cwdLabel ? ` · ${theme.fg("muted", cwdLabel)}` : ""} · ${run.status}${run.failureKind ? ` · ${run.failureKind}` : ""} · ${formatDuration(delegationDurationMs(run))} · ${formatDelegationCostLabel(run)} · ${formatDelegationContextLabel(run)}`));
+  if (workspaceLabel) lines.push(theme.fg("accent", workspaceLabel));
   if (run.usage) lines.push(theme.fg("muted", `usage · in ${run.usage.input} · out ${run.usage.output} · cache ${run.usage.cacheRead}/${run.usage.cacheWrite} · context ${run.usage.contextTokens}`));
   if (run.taskPreview) lines.push(theme.fg("muted", `task · ${sanitizeDelegationText(run.taskPreview)}`));
   renderLiveActivityCard(run, repoRoot, lines, safeWidth, theme);

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

@@ -1,5 +1,5 @@
 import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "node:fs";
-import { resolve, sep } from "node:path";
+import { relative, resolve, sep } from "node:path";
 
 import type { ChildResult, DelegationFailureKind } from "../types.js";
 import { isRecord } from "../core/utils/records.js";
@@ -29,6 +29,7 @@ export interface DelegationRunView {
   endedAtMs?: number;
   outputPreview: string;
   stderrPreview: string;
+  cwd?: string;
   sessionPath?: string;
   exitCode?: number;
   gatePassed?: boolean;
@@ -255,6 +256,29 @@ export function formatDelegationModelLabel(run: DelegationRunView | { model?: st
   return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
 }
 
+function delegationCwdValue(run: DelegationRunView | ChildResult | { cwd?: string } | undefined, repoRoot: string): string | undefined {
+  if (!run?.cwd) return undefined;
+  const resolvedRoot = resolve(repoRoot);
+  const resolvedCwd = resolve(run.cwd);
+  const rel = resolvedCwd === resolvedRoot ? "." : relative(resolvedRoot, resolvedCwd);
+  const inside = rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !rel.startsWith(sep));
+  return inside ? rel || "." : resolvedCwd;
+}
+
+function truncateLabel(label: string, limit: number): string {
+  return label.length <= limit ? label : `${label.slice(0, limit - 1)}…`;
+}
+
+export function formatDelegationCwdLabel(run: DelegationRunView | ChildResult | { cwd?: string } | undefined, repoRoot: string, limit = 48): string {
+  const value = delegationCwdValue(run, repoRoot);
+  return value ? truncateLabel(`cwd ${value}`, limit) : "";
+}
+
+export function formatDelegationWorkspaceLabel(run: DelegationRunView | ChildResult | { cwd?: string } | undefined, repoRoot: string, limit = 72): string {
+  const value = delegationCwdValue(run, repoRoot);
+  return value ? truncateLabel(`workspace · ${value}`, limit) : "";
+}
+
 function stripSignalControlSequences(text: string): string {
   return text
     .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "")
@@ -429,6 +453,7 @@ export function startDelegationRun(state: DelegationMonitorState, input: {
   agent: string;
   task: string;
   startedAtMs: number;
+  cwd?: string;
 }): DelegationRunView {
   const existingIndex = state.runs.findIndex((run) => run.id === input.id);
   const run: DelegationRunView = {
@@ -443,6 +468,7 @@ export function startDelegationRun(state: DelegationMonitorState, input: {
     startedAtMs: input.startedAtMs,
     outputPreview: "",
     stderrPreview: "",
+    cwd: input.cwd,
   };
   if (existingIndex >= 0) state.runs[existingIndex] = run;
   else state.runs.push(run);
@@ -463,6 +489,7 @@ export function updateDelegationRun(state: DelegationMonitorState, id: string, p
   if (patch.endedAtMs !== undefined) run.endedAtMs = patch.endedAtMs;
   if (patch.outputPreview !== undefined) run.outputPreview = capPreview(patch.outputPreview);
   if (patch.stderrPreview !== undefined) run.stderrPreview = capPreview(patch.stderrPreview);
+  if (patch.cwd !== undefined) run.cwd = patch.cwd;
   if (patch.sessionPath !== undefined) run.sessionPath = patch.sessionPath;
   if (patch.exitCode !== undefined) run.exitCode = patch.exitCode;
   if (patch.gatePassed !== undefined) run.gatePassed = patch.gatePassed;
@@ -539,6 +566,7 @@ export function buildDelegationLogLines(run: DelegationRunView | undefined, repo
     `[delegation ${run.id}]`,
     `agent: ${run.agent}`,
     run.model ? `model: ${run.model}` : undefined,
+    formatDelegationWorkspaceLabel(run, repoRoot) || undefined,
     `status: ${run.status}`,
     `duration: ${formatDuration(delegationDurationMs(run))}`,
     run.sessionPath ? `session: ${run.sessionPath}` : "session: not captured yet",

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

@@ -2,7 +2,7 @@ import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { matchesKey, truncateToWidth, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 
 import type { DelegationMonitorState, DelegationRunView, DelegationSortMode } from "./delegation-monitor.js";
-import { buildDelegationGroups, delegationCost, delegationDurationMs, delegationSignalBadge, delegationSignalColor, formatDelegationContextLabel, formatDelegationCost, formatDelegationCostLabel, formatDelegationModelLabel, formatDelegationSignalBadge, formatDuration, statusIcon } from "./delegation-monitor.js";
+import { buildDelegationGroups, delegationCost, delegationDurationMs, delegationSignalBadge, delegationSignalColor, formatDelegationContextLabel, formatDelegationCost, formatDelegationCostLabel, formatDelegationCwdLabel, formatDelegationModelLabel, formatDelegationSignalBadge, formatDelegationWorkspaceLabel, formatDuration, statusIcon } from "./delegation-monitor.js";
 import { delegationFeedFingerprint, renderDelegationFeedLines } from "./delegation-feed.js";
 import { delegateCloseButton, delegateSelectMarker } from "./delegation-click-markers.js";
 import { disableDelegationMouseMode, enableDelegationMouseMode, handleDelegationMouseInput } from "./delegation-mouse.js";
@@ -247,8 +247,9 @@ export class DelegationOverlayComponent implements Component {
     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 selectedWorkspaceLabel = formatDelegationWorkspaceLabel(selected, this.repoRoot, 42);
     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(statusColor(selected.status), `${statusIcon(selected.status)} ${selected.agent}`)}${selectedBadgeText ? ` ${th.fg(delegationSignalColor(selectedBadge), selectedBadgeText)}` : ""}${formatDelegationModelLabel(selected) ? ` ${th.fg("muted", `(${formatDelegationModelLabel(selected)})`)}` : ""}${selectedWorkspaceLabel ? ` ${th.fg("muted", selectedWorkspaceLabel)}` : ""} ${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));
@@ -432,7 +433,8 @@ export class DelegationOverlayComponent implements Component {
     const badge = formatDelegationSignalBadge(delegationSignalBadge(run));
     const modelLabel = formatDelegationModelLabel(run);
     const modelSuffix = modelLabel ? ` (${modelLabel})` : "";
-    const base = `${row.label}${badge ? ` ${badge}` : ""}${modelSuffix} ${duration} ${cost} ${context} [view]`;
+    const cwdSuffix = formatDelegationCwdLabel(run, this.repoRoot, 28);
+    const base = `${row.label}${badge ? ` ${badge}` : ""}${modelSuffix}${cwdSuffix ? ` ${cwdSuffix}` : ""} ${duration} ${cost} ${context} [view]`;
     const labeled = `${truncateToWidth(base, width - (selected ? 2 : 0), "…")}${delegateSelectMarker(run.id)}`;
     const colored = th.fg(statusColor(run.status), labeled);
     return selected ? th.bg("selectedBg", padToWidth(colored, width)) : colored;

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

@@ -39,6 +39,7 @@ import { extractModeIntent, stripModeIntentMarkup, validateModeIntent, type ZobM
 import { capturePlanArtifact } from "./plan-capture.js";
 import { redactPlanTodosBlockForDisplay } from "../domains/plan/plan-todos.js";
 import { applyMode, renderHarnessWidget } from "./widget.js";
+import { createStopRestoreCandidate, markStopRestoreAssistantMessage, markStopRestoreToolVisible } from "./stop-restore.js";
 
 function safelyUpdateZobLivePeer(repoRoot: string, action: "register" | "touch" | "unregister"): void {
   try {
@@ -937,6 +938,15 @@ export function registerHarnessEvents(pi: ExtensionAPI, state: HarnessRuntimeSta
         return { action: "continue" as const };
       }
       state.lastUserInputText = event.text;
+      const streamingBehavior = (event as { streamingBehavior?: unknown }).streamingBehavior;
+      const stopRestoreCandidate = createStopRestoreCandidate({
+        text: event.text,
+        source: event.source,
+        streamingBehavior: streamingBehavior === "steer" || streamingBehavior === "followUp" ? streamingBehavior : undefined,
+        leafId: ctx.sessionManager.getLeafId(),
+      });
+      if (stopRestoreCandidate) state.stopRestoreCandidate = stopRestoreCandidate;
+      else if (!streamingBehavior) state.stopRestoreCandidate = undefined;
       if (!event.text.trim().startsWith("/") && state.autonomy.enabled) {
         const readiness = scoreMissionReadiness(event.text, { mode: state.autonomy.mode, policy: state.autonomy.policy });
         state.autonomy.lastReadiness = readiness;
@@ -1002,6 +1012,36 @@ export function registerHarnessEvents(pi: ExtensionAPI, state: HarnessRuntimeSta
     return { action: "continue" as const };
   });
 
+  pi.on("message_start", async (event, ctx) => {
+    if (!isRecord(event.message)) return undefined;
+    if (event.message.role === "user") {
+      const text = textFromMessage(event.message as AssistantLikeMessage);
+      const stopRestoreCandidate = createStopRestoreCandidate({
+        text,
+        source: "interactive",
+        leafId: ctx.sessionManager.getLeafId(),
+      });
+      if (stopRestoreCandidate) state.stopRestoreCandidate = stopRestoreCandidate;
+      return undefined;
+    }
+    if (event.message.role === "assistant") {
+      markStopRestoreAssistantMessage(state.stopRestoreCandidate, event.message as AssistantLikeMessage);
+    }
+    return undefined;
+  });
+
+  pi.on("message_update", async (event) => {
+    if (isRecord(event.message) && event.message.role === "assistant") {
+      markStopRestoreAssistantMessage(state.stopRestoreCandidate, event.message as AssistantLikeMessage);
+    }
+    return undefined;
+  });
+
+  pi.on("tool_execution_start", async () => {
+    markStopRestoreToolVisible(state.stopRestoreCandidate);
+    return undefined;
+  });
+
   pi.on("tool_call", async (event, ctx) => {
     if (state.activeMode === "vanilla") return { action: "continue" as const };
 
@@ -1072,6 +1112,7 @@ export function registerHarnessEvents(pi: ExtensionAPI, state: HarnessRuntimeSta
 
   pi.on("message_end", async (event, ctx) => {
     if (!isRecord(event.message) || event.message.role !== "assistant") return undefined;
+    markStopRestoreAssistantMessage(state.stopRestoreCandidate, event.message as AssistantLikeMessage);
     const text = textFromMessage(event.message as AssistantLikeMessage);
     const visibleText = stripModeIntentMarkup(text);
     let capturedPlanPath: string | undefined;

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

@@ -45,6 +45,7 @@ const TaskItem = Type.Object({
 const DelegateParams = Type.Object({
   agent: Type.Optional(Type.String({ description: "Agent name for single-agent mode" })),
   task: Type.Optional(Type.String({ description: "Task for single-agent mode" })),
+  cwd: Type.Optional(Type.String({ description: "Default cwd for delegate_agent child Pi processes. Must stay inside repo; tasks[].cwd and chain[].cwd override this value." })),
   tasks: Type.Optional(Type.Array(TaskItem, { description: "Parallel tasks. Max 8, 4 concurrent." })),
   chain: Type.Optional(Type.Array(TaskItem, { description: "Sequential chain. {previous} is replaced by prior output." })),
   scope: Type.Optional(AgentScopeSchema),

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

@@ -19,6 +19,7 @@ import type { ZobModeIntent } from "./mode-intent.js";
 import type { ZAgentRoomBinding } from "../domains/coms/zagents.js";
 import { createZcompactRuntimeState, restoreZcompactStateFromBranch, type ZcompactRuntimeState } from "./auto-compaction.js";
 import { createZcommitRuntimeState, recordZcommitOwnedPath, type ZcommitLastCommitRecord, type ZcommitOwnershipSource, type ZcommitRuntimeState, type ZcommitToggleState } from "../domains/git/git-ops.js";
+import type { StopRestoreCandidate } from "./stop-restore.js";
 
 export interface DelegationMouseRuntimeState {
   tui?: TUI;
@@ -153,6 +154,7 @@ export interface HarnessRuntimeState {
   runtimeGoalLastAccountedAtMs?: number;
   activeRuleResolution?: RuleResolution;
   lastUserInputText?: string;
+  stopRestoreCandidate?: StopRestoreCandidate;
   lastModeIntent?: ZobModeIntent & { at: number; accepted: boolean; validationReason: string };
   delegations: DelegationMonitorState;
   delegationMouse: DelegationMouseRuntimeState;
@@ -181,6 +183,7 @@ export function createHarnessRuntimeState(): HarnessRuntimeState {
     runtimeGoalLastAccountedAtMs: undefined,
     activeRuleResolution: undefined,
     lastUserInputText: undefined,
+    stopRestoreCandidate: undefined,
     lastModeIntent: undefined,
     delegations: createDelegationMonitorState(),
     delegationMouse: { enabled: false, opening: false, mouseReleaseEpoch: 0 },

package/.pi/extensions/zob-harness/src/runtime/stop-restore.ts

@@ -0,0 +1,144 @@
+import type { AssistantLikeMessage } from "../types.js";
+import { sha256 } from "../core/utils/hashing.js";
+import { isRecord } from "../core/utils/records.js";
+
+export type StopRestoreInputSource = "interactive" | "rpc";
+export type StopRestoreStreamingBehavior = "steer" | "followUp";
+
+export interface StopRestoreCandidate {
+  schema: "zob.stop-restore-candidate.v1";
+  promptText: string;
+  promptHash: string;
+  source: StopRestoreInputSource;
+  inputAtMs: number;
+  leafId: string | null;
+  assistantStarted: boolean;
+  assistantVisibleOutput: boolean;
+  toolVisibleOutput: boolean;
+  restoredAtMs?: number;
+}
+
+export interface StopRestoreCandidateInput {
+  text: string;
+  source: string;
+  streamingBehavior?: StopRestoreStreamingBehavior;
+  leafId?: string | null;
+  nowMs?: number;
+}
+
+export interface StopRestoreDecisionInput {
+  foregroundAbortRequested: boolean;
+  idleBeforeStop: boolean;
+  pendingMessagesBeforeStop: boolean;
+  nowMs?: number;
+  maxCandidateAgeMs?: number;
+}
+
+export interface StopRestoreDecision {
+  restore: boolean;
+  reason: string;
+  promptText?: string;
+  promptHash?: string;
+  assistantOutputObserved: boolean;
+}
+
+export interface StopRestoreRewindResult {
+  attempted: boolean;
+  succeeded: boolean;
+  reason: string;
+  targetEntryId?: string;
+}
+
+const DEFAULT_MAX_CANDIDATE_AGE_MS = 30 * 60 * 1000;
+
+function restorablePromptText(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("/");
+}
+
+export function createStopRestoreCandidate(input: StopRestoreCandidateInput): StopRestoreCandidate | undefined {
+  if (input.source !== "interactive" && input.source !== "rpc") return undefined;
+  if (input.streamingBehavior) return undefined;
+  if (!restorablePromptText(input.text)) return undefined;
+  return {
+    schema: "zob.stop-restore-candidate.v1",
+    promptText: input.text,
+    promptHash: sha256(input.text),
+    source: input.source,
+    inputAtMs: input.nowMs ?? Date.now(),
+    leafId: input.leafId ?? null,
+    assistantStarted: false,
+    assistantVisibleOutput: false,
+    toolVisibleOutput: false,
+  };
+}
+
+export function assistantMessageHasVisibleOutput(message: AssistantLikeMessage | undefined): boolean {
+  if (!message || !Array.isArray(message.content)) return false;
+  return message.content.some((part) => {
+    if (!isRecord(part)) return false;
+    if (part.type === "text") return typeof part.text === "string" && part.text.trim().length > 0;
+    if (part.type === "thinking") return typeof part.thinking === "string" && part.thinking.trim().length > 0;
+    if (part.type === "toolCall") return true;
+    return false;
+  });
+}
+
+export function markStopRestoreAssistantMessage(candidate: StopRestoreCandidate | undefined, message: AssistantLikeMessage | undefined): void {
+  if (!candidate || candidate.restoredAtMs) return;
+  candidate.assistantStarted = true;
+  if (assistantMessageHasVisibleOutput(message)) candidate.assistantVisibleOutput = true;
+}
+
+export function markStopRestoreToolVisible(candidate: StopRestoreCandidate | undefined): void {
+  if (!candidate || candidate.restoredAtMs) return;
+  candidate.toolVisibleOutput = true;
+}
+
+function textFromEntryContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part): part is { type: string; text: string } => isRecord(part) && part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("");
+}
+
+export function findStopRestoreUserEntryId(candidate: StopRestoreCandidate | undefined, entries: unknown[]): string | undefined {
+  if (!candidate) return undefined;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (!isRecord(entry) || entry.type !== "message" || typeof entry.id !== "string") continue;
+    const parentId = typeof entry.parentId === "string" ? entry.parentId : entry.parentId === null ? null : undefined;
+    if (parentId !== candidate.leafId) continue;
+    if (!isRecord(entry.message) || entry.message.role !== "user") continue;
+    if (textFromEntryContent(entry.message.content) === candidate.promptText) return entry.id;
+  }
+  return undefined;
+}
+
+export function markStopRestoreRestored(candidate: StopRestoreCandidate | undefined, nowMs = Date.now()): void {
+  if (!candidate) return;
+  candidate.restoredAtMs = nowMs;
+}
+
+export function shouldRestoreStopPrompt(candidate: StopRestoreCandidate | undefined, input: StopRestoreDecisionInput): StopRestoreDecision {
+  const assistantOutputObserved = Boolean(candidate?.assistantVisibleOutput || candidate?.toolVisibleOutput);
+  if (!candidate) return { restore: false, reason: "no_candidate", assistantOutputObserved };
+  if (!input.foregroundAbortRequested) return { restore: false, reason: "foreground_idle", assistantOutputObserved };
+  if (input.idleBeforeStop) return { restore: false, reason: "idle_before_stop", assistantOutputObserved };
+  if (input.pendingMessagesBeforeStop) return { restore: false, reason: "pending_messages_restored_by_pi", assistantOutputObserved };
+  if (candidate.restoredAtMs) return { restore: false, reason: "already_restored", promptHash: candidate.promptHash, assistantOutputObserved };
+  if (!restorablePromptText(candidate.promptText)) return { restore: false, reason: "non_restorable_prompt", promptHash: candidate.promptHash, assistantOutputObserved };
+  if (assistantOutputObserved) return { restore: false, reason: "assistant_output_observed", promptHash: candidate.promptHash, assistantOutputObserved };
+  const nowMs = input.nowMs ?? Date.now();
+  const maxAgeMs = input.maxCandidateAgeMs ?? DEFAULT_MAX_CANDIDATE_AGE_MS;
+  if (nowMs - candidate.inputAtMs > maxAgeMs) return { restore: false, reason: "candidate_stale", promptHash: candidate.promptHash, assistantOutputObserved };
+  return {
+    restore: true,
+    reason: "foreground_aborted_before_assistant_output",
+    promptText: candidate.promptText,
+    promptHash: candidate.promptHash,
+    assistantOutputObserved,
+  };
+}

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

@@ -32,7 +32,9 @@ import {
   delegationSignalColor,
   extractDelegationSignalBadge,
   finishDelegationRun,
+  formatDelegationCwdLabel,
   formatDelegationModelLabel,
+  formatDelegationWorkspaceLabel,
   formatDelegationSignalBadge,
   formatDuration,
   hasActiveDelegations,
@@ -625,6 +627,7 @@ export function hydrateDelegationRunsFromDetails(source: "delegate_agent" | "del
         agent: result.agent,
         task: result.task || "restored from delegate tool result",
         startedAtMs: nowMs - Math.max(1, index + 1),
+        cwd: result.cwd,
       });
     }
     finishDelegationRun(state.delegations, result.ledgerRunId, {
@@ -634,6 +637,7 @@ export function hydrateDelegationRunsFromDetails(source: "delegate_agent" | "del
       index,
       agent: result.agent,
       model: result.model,
+      cwd: result.cwd,
       status: result.stopReason === "aborted" ? "aborted" : isFailed(result) ? "failed" : "complete",
       endedAtMs: existing?.endedAtMs ?? nowMs,
       outputPreview: result.output,
@@ -730,6 +734,16 @@ export function formatDelegationCatalogSummary(catalog: Record<string, unknown>)
   return lines.join("\n");
 }
 
+function formatWorkspaceSummaryLine(items: Array<DelegationRunView | ChildResult>, repoRoot: string): string {
+  const workspaces = [...new Set(items.map((item) => formatDelegationWorkspaceLabel(item, repoRoot, 72)).filter(Boolean))];
+  if (workspaces.length === 0) return "";
+  if (workspaces.length === 1) return workspaces[0] ?? "";
+  const values = workspaces.map((label) => label.replace(/^workspace · /, ""));
+  const visible = values.slice(0, 3).join(", ");
+  const suffix = values.length > 3 ? `, +${values.length - 3} more` : "";
+  return `workspaces · ${visible}${suffix}`;
+}
+
 function renderMiniActivityLines(run: DelegationRunView, nowMs: number, expanded: boolean, theme: { fg: (color: any, text: string) => string }): string[] {
   const lines: string[] = [];
   const snapshot = readDelegationActivitySnapshot(run.sessionPath, process.cwd(), nowMs);
@@ -770,8 +784,10 @@ export function renderDelegationToolResultText(source: "delegate_agent" | "deleg
   const mode = details?.mode ?? (source === "delegate_task" ? "single" : "single");
   const lines = [
     `${theme.fg("toolTitle", theme.bold(source))} ${theme.fg("accent", mode)} ${isPartial ? theme.fg("warning", "running") : theme.fg(failCount > 0 ? "error" : "success", `${okCount}/${results.length || monitoredRuns.length || 1} ok`)}`,
-    `${theme.fg("dim", "running")} ${theme.fg(runningCount > 0 ? "warning" : "dim", String(runningCount))} ${theme.fg("dim", "blocked")} ${theme.fg(blockedCount > 0 ? "warning" : "dim", String(blockedCount))} ${theme.fg("dim", "gate")} ${theme.fg(gateCount > 0 ? "warning" : "dim", String(gateCount))} ${theme.fg("dim", "runtime")} ${theme.fg(runtimeCount > 0 ? "error" : "dim", String(runtimeCount))} ${theme.fg("dim", "details")} ${theme.fg("muted", "/zstatus delegations")}`,
   ];
+  const workspaceSummary = formatWorkspaceSummaryLine(monitoredRuns.length > 0 ? monitoredRuns : results, process.cwd());
+  if (workspaceSummary) lines.push(theme.fg("accent", workspaceSummary));
+  lines.push(`${theme.fg("dim", "running")} ${theme.fg(runningCount > 0 ? "warning" : "dim", String(runningCount))} ${theme.fg("dim", "blocked")} ${theme.fg(blockedCount > 0 ? "warning" : "dim", String(blockedCount))} ${theme.fg("dim", "gate")} ${theme.fg(gateCount > 0 ? "warning" : "dim", String(gateCount))} ${theme.fg("dim", "runtime")} ${theme.fg(runtimeCount > 0 ? "error" : "dim", String(runtimeCount))} ${theme.fg("dim", "details")} ${theme.fg("muted", "/zstatus delegations")}`);
 
   if (monitoredRuns.length > 0) {
     const maxRows = expanded ? 12 : 5;
@@ -787,7 +803,9 @@ export function renderDelegationToolResultText(source: "delegate_agent" | "deleg
       const badgeText = formatDelegationSignalBadge(badge);
       const modelLabel = formatDelegationModelLabel(run);
       const modelSuffix = modelLabel ? ` ${theme.fg("muted", `(${modelLabel})`)}` : "";
-      lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${statusIcon(run.status)} ${run.agent}${kind}${background}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix} ${theme.fg("dim", formatDuration(delegationDurationMs(run, nowMs)))} ${theme.fg("muted", viewHint)}`);
+      const cwdLabel = formatDelegationCwdLabel(run, process.cwd(), 36);
+      const cwdSuffix = cwdLabel ? ` ${theme.fg("muted", cwdLabel)}` : "";
+      lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${statusIcon(run.status)} ${run.agent}${kind}${background}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix}${cwdSuffix} ${theme.fg("dim", formatDuration(delegationDurationMs(run, nowMs)))} ${theme.fg("muted", viewHint)}`);
       lines.push(...renderMiniActivityLines(run, nowMs, expanded, theme));
       if (expanded && (run.errorMessage || run.stopReason || run.gateErrors?.length)) lines.push(`   ${theme.fg("dim", run.errorMessage ?? run.gateErrors?.join("; ") ?? run.stopReason ?? "")}`);
     }
@@ -808,7 +826,9 @@ export function renderDelegationToolResultText(source: "delegate_agent" | "deleg
     const badgeText = formatDelegationSignalBadge(badge);
     const modelLabel = formatDelegationModelLabel(result);
     const modelSuffix = modelLabel ? ` ${theme.fg("muted", `(${modelLabel})`)}` : "";
-    lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${failed ? "✗" : "✓"} ${result.agent}${kind}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix} ${theme.fg("dim", result.ledgerRunId ?? "")} ${theme.fg("muted", viewHint)}`);
+    const cwdLabel = formatDelegationCwdLabel(result, process.cwd(), 36);
+    const cwdSuffix = cwdLabel ? ` ${theme.fg("muted", cwdLabel)}` : "";
+    lines.push(`${theme.fg("dim", prefix)} ${theme.fg(color, `${failed ? "✗" : "✓"} ${result.agent}${kind}`)}${badgeText ? ` ${theme.fg(delegationSignalColor(badge), badgeText)}` : ""}${modelSuffix}${cwdSuffix} ${theme.fg("dim", result.ledgerRunId ?? "")} ${theme.fg("muted", viewHint)}`);
     if (expanded && result.output.trim()) lines.push(`   ${theme.fg("muted", result.output.split("\n")[0] ?? "")}`);
   }
   if (hasMore) lines.push(theme.fg("dim", `└─ … ${results.length - maxRows} more result(s)`));

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

@@ -32,6 +32,7 @@ import {
   delegationSignalColor,
   extractDelegationSignalBadge,
   finishDelegationRun,
+  formatDelegationCwdLabel,
   formatDelegationModelLabel,
   formatDelegationSignalBadge,
   formatDuration,
@@ -109,6 +110,8 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
       "If agent routing is uncertain, call zob_delegation_catalog before the first delegation.",
       "Use delegate_agent for broad discovery, external research, skeptical review, or independent QA before making risky edits.",
       "When using delegate_agent, give each child a bounded six-part contract and a concrete final output shape.",
+      "Optional cwd spawns the child inside that repo-local working directory; tasks[].cwd and chain[].cwd override delegate_agent top-level cwd defaults.",
+      "cwd only selects the child working directory; it does not replace allowed_paths or write-scope grants.",
       "If effective tools include edit/write, provide non-empty repo-relative-only allowed_paths; use repo-local reports/... snapshot/context_ref refs for external context.",
     ],
     parameters: DelegateParams,
@@ -169,6 +172,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
         const startedAt = new Date(startedAtMs).toISOString();
         const requestedTools = parseToolList(params.tools);
         const effectiveThinking = item.thinking ?? params.thinking;
+        const cwdResult = resolveChildCwd(ctx.cwd, item.cwd ?? params.cwd);
         startDelegationRun(state.delegations, {
           id: runId,
           parentToolCallId: toolCallId,
@@ -178,6 +182,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           agent: item.agent,
           task: taskText,
           startedAtMs,
+          cwd: cwdResult.cwd,
         });
         renderDelegationMonitor();
         const agent = byName.get(item.agent.toLowerCase());
@@ -193,6 +198,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             gateErrors: ["unknown agent"],
             failureKind: "config",
             usage: usageEmpty(),
+            cwd: cwdResult.cwd,
           };
           const endedAtMs = Date.now();
           const endedAt = new Date(endedAtMs).toISOString();
@@ -203,7 +209,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             ...delegationLedgerMeta("delegate_agent", toolCallId, monitor.mode, monitor.index),
             agent: item.agent,
             taskHash: sha256(taskText),
-            cwd: resolveChildCwd(ctx.cwd, item.cwd).cwd,
+            cwd: cwdResult.cwd,
             tools: requestedTools ?? [],
             errors: ["unknown agent"],
             failureKind: result.failureKind,
@@ -216,7 +222,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             mode: state.activeMode,
             agent: item.agent,
             model: params.model,
-            cwd: resolveChildCwd(ctx.cwd, item.cwd).cwd,
+            cwd: cwdResult.cwd,
             tools: requestedTools ?? [],
             taskHash: sha256(taskText),
             outputContract: inferOutputContract(item.agent),
@@ -240,14 +246,14 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             failureKind: result.failureKind,
             errorMessage: "Configuration blocked; no child launched: unknown agent",
             model: params.model,
+            cwd: cwdResult.cwd,
           });
           recordTodoClaimFromChildResult(pi, state, effectiveChildGoal, result);
           renderDelegationMonitor();
           return result;
         }
 
-        updateDelegationRun(state.delegations, runId, { agent: agent.name });
-        const cwdResult = resolveChildCwd(ctx.cwd, item.cwd);
+        updateDelegationRun(state.delegations, runId, { agent: agent.name, cwd: cwdResult.cwd });
         const effectiveTools = requestedTools ?? agent.tools ?? [];
         const preflightErrors = [
           ...strictGoalErrors(state),
@@ -275,6 +281,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             gateErrors: preflightErrors,
             failureKind: classifyConfigOrPreflight(preflightErrors),
             usage: usageEmpty(),
+            cwd: cwdResult.cwd,
           };
           const endedAtMs = Date.now();
           const endedAt = new Date(endedAtMs).toISOString();
@@ -321,6 +328,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             failureKind: result.failureKind,
             errorMessage: `${result.failureKind === "config" ? "Configuration blocked" : "Preflight blocked"}; no child launched: ${preflightErrors.join("; ")}`,
             model: params.model ?? agent.model,
+            cwd: cwdResult.cwd,
           });
           recordTodoClaimFromChildResult(pi, state, effectiveChildGoal, result);
           renderDelegationMonitor();
@@ -349,6 +357,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
         const childPathPolicy = { allowedPaths: params.allowed_paths, forbiddenPaths: params.forbidden_paths };
         const beforeChildDirty = toolsEnableWrites(effectiveChildTools) ? captureZcommitChildDirtySnapshot(ctx.cwd, childPathPolicy) : undefined;
         const result = await runChildAgent(ctx, agent, taskText, cwdResult.cwd, signal, params.model, requestedTools?.join(","), (partial) => {
+          partial.cwd = cwdResult.cwd;
           updateDelegationRun(state.delegations, runId, {
             status: partial.stopReason === "aborted" ? "aborted" : "running",
             agent: partial.agent,
@@ -356,6 +365,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             outputPreview: partial.output,
             stderrPreview: partial.stderr,
             sessionPath: partial.sessionPath,
+            cwd: cwdResult.cwd,
             stopReason: partial.stopReason,
             errorMessage: partial.errorMessage,
             usage: partial.usage,
@@ -363,6 +373,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           renderDelegationMonitor();
           update?.(partial);
         }, childPathPolicy, effectiveThinking);
+        result.cwd = cwdResult.cwd;
         result.childChangedPaths = captureChildDirtyDelta(ctx.cwd, childPathPolicy, beforeChildDirty);
         result.ledgerRunId = runId;
         result.outputContract = outputContract;
@@ -480,6 +491,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           childChangedPaths: result.childChangedPaths,
           usage: result.usage,
           model: result.model,
+          cwd: cwdResult.cwd,
         });
         if (shouldRunAgenticClaimValidation(effectiveChildGoal, claimRecord)) {
           await runAgenticTodoClaimValidation({ ctx, pi, state, childGoal: effectiveChildGoal, claimRecord, parentRunId: runId, appendDelegationLedger, signal, modelOverride: params.model, allowedPaths: params.allowed_paths, forbiddenPaths: params.forbidden_paths });
@@ -491,7 +503,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
       if (params.agent && params.task) {
         startMonitorTicker();
         try {
-          const result = await runOne({ agent: params.agent, task: params.task, thinking: params.thinking, child_goal: params.child_goal }, { mode: "single", index: 0 }, (partial) => {
+          const result = await runOne({ agent: params.agent, task: params.task, cwd: params.cwd, thinking: params.thinking, child_goal: params.child_goal }, { mode: "single", index: 0 }, (partial) => {
             onUpdate?.({ content: [{ type: "text", text: partial.output || partial.stderr || "running..." }], details: makeDetails("single", [partial]) });
           });
           return {
@@ -519,7 +531,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             return result;
           });
           const successCount = results.filter((result) => !isFailed(result)).length;
-          const summaries = results.map((result) => `### ${result.agent} — ${isFailed(result) ? "FAILED/INCOMPLETE" : "OK"}\n\n${capOutput(formatChildResultText(result))}`);
+          const summaries = results.map((result) => `### ${result.agent} — ${isFailed(result) ? "FAILED/INCOMPLETE" : "OK"}${formatDelegationCwdLabel(result, ctx.cwd) ? ` · ${formatDelegationCwdLabel(result, ctx.cwd)}` : ""}\n\n${capOutput(formatChildResultText(result))}`);
           return {
             content: [{ type: "text", text: `Parallel delegation: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n---\n\n")}` }],
             details: makeDetails("parallel", results),
@@ -542,7 +554,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             results.push(result);
             if (isFailed(result)) {
               return {
-                content: [{ type: "text", text: `Chain stopped at step ${index + 1} (${result.agent}):\n\n${formatChildResultText(result)}` }],
+                content: [{ type: "text", text: `Chain stopped at step ${index + 1} (${result.agent}${formatDelegationCwdLabel(result, ctx.cwd) ? ` · ${formatDelegationCwdLabel(result, ctx.cwd)}` : ""}):\n\n${formatChildResultText(result)}` }],
                 details: makeDetails("chain", results),
               };
             }
@@ -572,6 +584,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
       "Use delegate_task when you need strict preflight rather than a freeform delegated prompt.",
       "Normally omit output_contract; the harness infers it from the selected agent. Do not invent output contract ids.",
       "Normally omit required_tools; the harness infers the selected agent's declared tools. Only set required_tools to intentionally narrow tools.",
+      "Optional cwd spawns the child inside that repo-local working directory; it only selects cwd and does not replace allowed_paths or write-scope grants.",
       "If effective tools include edit/write, set top-level original_user_ask to the original human request; context or task text does not satisfy the strict write preflight gate.",
       "Use canonical JSON keys expected_outcome, must_do, must_not_do, context, original_user_ask, allowed_paths, forbidden_paths; safe aliases are accepted only when non-conflicting.",
       "Accepted aliases: expectedOutcome, mustDo, mustNotDo/must_not/mustNot, originalUserAsk, allowedPaths, forbiddenPaths, requiredTools, outputContract, runInBackground, childGoal, loadSkills.",
@@ -598,6 +611,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
       const effectiveChildGoal = childGoalResolution.childGoal;
       const startedAtMs = Date.now();
       const startedAt = new Date(startedAtMs).toISOString();
+      const cwdResult = resolveChildCwd(ctx.cwd, params.cwd);
       const appendDelegationLedger = (entry: Record<string, unknown>): void => {
         appendLedgerFile(ctx.cwd, entry);
         pi.appendEntry("zob-delegation", entry);
@@ -635,6 +649,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
         agent: params.agent,
         task: params.task,
         startedAtMs,
+        cwd: cwdResult.cwd,
       });
       renderDelegationMonitor();
       startMonitorTicker();
@@ -652,6 +667,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           gateErrors: ["unknown agent"],
           failureKind: "config",
           usage: usageEmpty(),
+          cwd: cwdResult.cwd,
         };
         const endedAtMs = Date.now();
         const endedAt = new Date(endedAtMs).toISOString();
@@ -662,7 +678,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           ...delegationLedgerMeta("delegate_task", toolCallId, "single", 0),
           agent: params.agent,
           taskHash: sha256(params.task),
-          cwd: resolveChildCwd(ctx.cwd, params.cwd).cwd,
+          cwd: cwdResult.cwd,
           tools: params.required_tools ?? [],
           errors: ["unknown agent"],
           failureKind: result.failureKind,
@@ -675,7 +691,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           mode: state.activeMode,
           agent: params.agent,
           model: params.model,
-          cwd: resolveChildCwd(ctx.cwd, params.cwd).cwd,
+          cwd: cwdResult.cwd,
           tools: params.required_tools ?? [],
           taskHash: sha256(params.task),
           outputContract: params.output_contract ?? inferOutputContract(params.agent),
@@ -699,13 +715,14 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           failureKind: result.failureKind,
           errorMessage: "Configuration blocked; no child launched: unknown agent",
           model: params.model,
+          cwd: cwdResult.cwd,
         });
         recordTodoClaimFromChildResult(pi, state, effectiveChildGoal, result);
         stopMonitorTicker();
         return { content: [{ type: "text", text: formatChildResultText(result) }], details: { mode: "single", results: [result], agents: agents.map((candidate) => candidate.name) } };
       }
 
-      updateDelegationRun(state.delegations, runId, { agent: agent.name });
+      updateDelegationRun(state.delegations, runId, { agent: agent.name, cwd: cwdResult.cwd });
       const requestedOutputContract = params.output_contract ?? inferOutputContract(agent.name);
       const effectiveTools = params.required_tools?.length ? params.required_tools : agent.tools ?? [];
 
@@ -728,7 +745,6 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
         .filter((part): part is string => typeof part === "string")
         .join("\n");
 
-      const cwdResult = resolveChildCwd(ctx.cwd, params.cwd);
       const preflightErrors = [
         ...normalized.errors,
         ...strictGoalErrors(state),
@@ -759,6 +775,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           gateErrors: preflightErrors,
           failureKind: classifyConfigOrPreflight(preflightErrors),
           usage: usageEmpty(),
+          cwd: cwdResult.cwd,
         };
         const endedAtMs = Date.now();
         const endedAt = new Date(endedAtMs).toISOString();
@@ -805,6 +822,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           failureKind: result.failureKind,
           errorMessage: delegateTaskPreflightHelp(preflightErrors).replace(/\n/g, " "),
           model: params.model ?? agent.model,
+          cwd: cwdResult.cwd,
         });
         recordTodoClaimFromChildResult(pi, state, effectiveChildGoal, result);
         stopMonitorTicker();
@@ -834,6 +852,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
         const childPathPolicy = { allowedPaths: params.allowed_paths, forbiddenPaths: params.forbidden_paths };
         const beforeChildDirty = toolsEnableWrites(effectiveTools) ? captureZcommitChildDirtySnapshot(ctx.cwd, childPathPolicy) : undefined;
         const result = await runChildAgent(ctx, agent, structuredTask, cwdResult.cwd, childSignal, params.model, effectiveTools.join(","), (partial) => {
+          partial.cwd = cwdResult.cwd;
           updateDelegationRun(state.delegations, runId, {
             status: partial.stopReason === "aborted" ? "aborted" : "running",
             agent: partial.agent,
@@ -841,6 +860,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
             outputPreview: partial.output,
             stderrPreview: partial.stderr,
             sessionPath: partial.sessionPath,
+            cwd: cwdResult.cwd,
             stopReason: partial.stopReason,
             errorMessage: partial.errorMessage,
             usage: partial.usage,
@@ -848,6 +868,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           renderDelegationMonitor();
           if (emitToolUpdates) onUpdate?.({ content: [{ type: "text", text: partial.output || partial.stderr || "running..." }], details: { mode: "single", results: [partial], agents: agents.map((candidate) => candidate.name) } });
         }, childPathPolicy, params.thinking);
+        result.cwd = cwdResult.cwd;
         result.childChangedPaths = captureChildDirtyDelta(ctx.cwd, childPathPolicy, beforeChildDirty);
         result.ledgerRunId = runId;
         result.outputContract = outputContract;
@@ -966,6 +987,7 @@ export function registerDelegationTools(pi: ExtensionAPI, state: HarnessRuntimeS
           childChangedPaths: result.childChangedPaths,
           usage: result.usage,
           model: result.model,
+          cwd: cwdResult.cwd,
         });
         if (shouldRunAgenticClaimValidation(effectiveChildGoal, claimRecord)) {
           await runAgenticTodoClaimValidation({ ctx, pi, state, childGoal: effectiveChildGoal, claimRecord, parentRunId: runId, appendDelegationLedger, signal: childSignal, modelOverride: params.model, allowedPaths: params.allowed_paths, forbiddenPaths: params.forbidden_paths });
@@ -1092,6 +1114,7 @@ ${formatChildResultText(result)}` : result.output || "(no output)" }],
         failureKind: result.failureKind,
         stopReason: result.stopReason,
         stopCondition: result.stopCondition,
+        cwd: result.cwd,
         sessionPath: result.sessionPath,
       });
       const resultDetails = (result: ChildResult) => includeResult ? { result } : { resultSummary: compactResult(result), resultIncluded: false };

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

@@ -81,6 +81,7 @@ export interface ChildResult {
   exitCode: number;
   output: string;
   stderr: string;
+  cwd?: string;
   model?: string;
   sessionPath?: string;
   ledgerRunId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zob-harness",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "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",