@cydm/pie 1.0.36 → 1.0.38

package/dist/chunks/{chunk-QXTAEPLR.js → chunk-IKIEQTVJ.js}

@@ -8,10 +8,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-MGZHZSHB.js";
+} from "./chunk-2PLCSYFF.js";
 import {
   Type
-} from "./chunk-64XJIKVK.js";
+} from "./chunk-2WHIT2UB.js";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";

package/dist/chunks/{chunk-4B42ZU4B.js → chunk-NTFKTUOW.js}

@@ -3,7 +3,7 @@ import {
   EventStream,
   streamSimple,
   validateToolArguments
-} from "./chunk-64XJIKVK.js";
+} from "./chunk-2WHIT2UB.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {

package/dist/chunks/{src-27UD2ZBZ.js → src-PBRYPFUI.js}

@@ -3,8 +3,8 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-4B42ZU4B.js";
-import "./chunk-64XJIKVK.js";
+} from "./chunk-NTFKTUOW.js";
+import "./chunk-2WHIT2UB.js";
 import "./chunk-TG2EQLX2.js";
 export {
   Agent,

package/dist/chunks/{test-stream-L4PUYWQQ.js → test-stream-EO6L26M5.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-64XJIKVK.js";
+} from "./chunk-2WHIT2UB.js";
 import "./chunk-TG2EQLX2.js";
 
 // src/app/test-stream.ts

package/dist/cli.js

@@ -19,7 +19,7 @@ import {
   getThemesDir,
   migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-QXTAEPLR.js";
+} from "./chunks/chunk-IKIEQTVJ.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -69,8 +69,8 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-MGZHZSHB.js";
-import "./chunks/chunk-4B42ZU4B.js";
+} from "./chunks/chunk-2PLCSYFF.js";
+import "./chunks/chunk-NTFKTUOW.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -105,7 +105,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-64XJIKVK.js";
+} from "./chunks/chunk-2WHIT2UB.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -44905,6 +44905,7 @@ function validateCompat(value, label) {
   if (value === void 0) return;
   if (!isPlainRecord(value)) throw new Error(`${label} is invalid`);
   assertOnlyKeys(value, [
+    "forcedReasoningEffort",
     "supportsStore",
     "supportsDeveloperRole",
     "supportsReasoningEffort",
@@ -44916,6 +44917,9 @@ function validateCompat(value, label) {
     "supportsStrictMode",
     "cacheCapability"
   ], label);
+  if (value.forcedReasoningEffort !== void 0 && value.forcedReasoningEffort !== "none") {
+    throw new Error(`${label}.forcedReasoningEffort must be "none"`);
+  }
   for (const field of [
     "supportsStore",
     "supportsDeveloperRole",
@@ -46565,6 +46569,165 @@ function parseModelsCommandArgs(args) {
 
 // src/commands/sessions.ts
 import fs6 from "node:fs";
+
+// src/session-control.ts
+var SessionControlError = class extends Error {
+  constructor(code, message, recoverable = sessionControlErrorRecoverable(code)) {
+    super(message);
+    this.code = code;
+    this.recoverable = recoverable;
+    this.name = "SessionControlError";
+  }
+  code;
+  recoverable;
+};
+function sessionControlErrorRecoverable(code) {
+  return code !== "session_unrecoverable" && code !== "session_mismatch";
+}
+async function loadRequiredSession(store, sessionId) {
+  const exists = await store.exists(sessionId);
+  const data = await store.load(sessionId);
+  if (data) return data;
+  throw new SessionControlError(
+    exists ? "session_unrecoverable" : "session_not_found",
+    exists ? `Session could not be recovered: ${sessionId}` : `Session not found: ${sessionId}`
+  );
+}
+async function rewindStoredSession(params) {
+  const data = await loadRequiredSession(params.store, params.sessionId);
+  if (!data.entries.some((entry) => entry.id === params.entryId)) {
+    throw new SessionControlError("checkpoint_not_found", `Entry not found: ${params.entryId}`);
+  }
+  try {
+    await params.store.save(params.sessionId, data.entries, {
+      ...data.metadata,
+      activeEntryId: params.entryId,
+      updatedAt: params.now ?? Date.now()
+    });
+    const metadata = await params.store.getMetadata(params.sessionId);
+    if (!metadata) {
+      throw new SessionControlError("session_unrecoverable", `Session could not be recovered after rewind: ${params.sessionId}`, false);
+    }
+    return {
+      sessionId: params.sessionId,
+      entryId: params.entryId,
+      checkpointId: params.entryId,
+      activeEntryId: params.entryId,
+      headEntryId: params.entryId,
+      metadata
+    };
+  } catch (error) {
+    if (error instanceof SessionControlError) throw error;
+    throw new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+  }
+}
+async function forkStoredSession(params) {
+  try {
+    const existingTarget = await maybeLoadExistingForkTarget(params);
+    if (existingTarget) return existingTarget;
+    const source = await loadRequiredSession(params.store, params.sourceSessionId);
+    const pathEntries = pathToEntry(source, params.sourceEntryId);
+    if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1]?.id !== params.sourceEntryId) {
+      throw new SessionControlError("checkpoint_not_found", `Entry not found: ${params.sourceEntryId}`);
+    }
+    const now = params.now ?? Date.now();
+    const idMap = /* @__PURE__ */ new Map();
+    for (const entry of pathEntries) idMap.set(entry.id, generateEntryId());
+    const forkedEntries = pathEntries.map((entry) => {
+      const nextId = idMap.get(entry.id);
+      if (!nextId) throw new SessionControlError("session_io_error", `Failed to map entry: ${entry.id}`);
+      const parentId = entry.parentId ? idMap.get(entry.parentId) ?? null : null;
+      return {
+        ...cloneJson(entry),
+        id: nextId,
+        parentId,
+        timestamp: entry.timestamp
+      };
+    });
+    const activeEntryId = idMap.get(params.sourceEntryId);
+    if (!activeEntryId) {
+      throw new SessionControlError("session_io_error", `Failed to map active entry: ${params.sourceEntryId}`);
+    }
+    await params.store.save(params.targetSessionId, forkedEntries, {
+      name: params.name,
+      createdAt: now,
+      updatedAt: now,
+      activeEntryId,
+      cwd: params.cwd ?? source.metadata.cwd,
+      sourceSessionId: params.sourceSessionId,
+      sourceEntryId: params.sourceEntryId,
+      sourceActiveEntryId: source.metadata.activeEntryId ?? void 0,
+      forkBaseEntryId: activeEntryId,
+      ...params.requestId ? { sessionControlRequestId: params.requestId } : {}
+    });
+    const metadata = await params.store.getMetadata(params.targetSessionId);
+    if (!metadata) {
+      throw new SessionControlError("session_unrecoverable", `Session could not be recovered after fork: ${params.targetSessionId}`, false);
+    }
+    return buildForkResult({
+      metadata,
+      sourceSessionId: params.sourceSessionId,
+      sourceEntryId: params.sourceEntryId,
+      sourceActiveEntryId: source.metadata.activeEntryId ?? null
+    });
+  } catch (error) {
+    if (error instanceof SessionControlError) throw error;
+    throw new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+  }
+}
+async function maybeLoadExistingForkTarget(params) {
+  if (!await params.store.exists(params.targetSessionId)) return null;
+  const target = await params.store.load(params.targetSessionId);
+  if (!target) {
+    throw new SessionControlError("session_unrecoverable", `Session could not be recovered: ${params.targetSessionId}`, false);
+  }
+  const metadata = target.metadata;
+  if (params.requestId && metadata.sessionControlRequestId === params.requestId && metadata.sourceSessionId === params.sourceSessionId && metadata.sourceEntryId === params.sourceEntryId && typeof metadata.forkBaseEntryId === "string" && metadata.activeEntryId === metadata.forkBaseEntryId) {
+    return buildForkResult({
+      metadata,
+      sourceSessionId: params.sourceSessionId,
+      sourceEntryId: params.sourceEntryId,
+      sourceActiveEntryId: typeof metadata.sourceActiveEntryId === "string" ? metadata.sourceActiveEntryId : null
+    });
+  }
+  throw new SessionControlError("target_exists", `Target session already exists: ${params.targetSessionId}`);
+}
+function buildForkResult(params) {
+  const targetActiveEntryId = params.metadata.activeEntryId;
+  if (!targetActiveEntryId) {
+    throw new SessionControlError("session_unrecoverable", `Fork target has no active entry: ${params.metadata.id}`, false);
+  }
+  const forkBaseEntryId = typeof params.metadata.forkBaseEntryId === "string" ? params.metadata.forkBaseEntryId : targetActiveEntryId;
+  return {
+    sourceSessionId: params.sourceSessionId,
+    sourceEntryId: params.sourceEntryId,
+    sourceCheckpointId: params.sourceEntryId,
+    targetSessionId: params.metadata.id,
+    targetActiveEntryId,
+    targetHeadEntryId: targetActiveEntryId,
+    headEntryId: targetActiveEntryId,
+    sourceActiveEntryId: params.sourceActiveEntryId,
+    forkBaseEntryId,
+    metadata: params.metadata
+  };
+}
+function pathToEntry(data, entryId) {
+  const byId = new Map(data.entries.map((entry) => [entry.id, entry]));
+  const path31 = [];
+  let current = entryId;
+  while (current) {
+    const entry = byId.get(current);
+    if (!entry) return [];
+    path31.unshift(entry);
+    current = entry.parentId;
+  }
+  return path31;
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/commands/sessions.ts
 async function runSessionsCommand(args) {
   const command = args[0] || "help";
   const rest = args.slice(1);
@@ -46691,17 +46854,12 @@ async function rewindSession(args) {
   const entryId = stringFlag(args, "--to");
   if (!sessionId || !entryId) throw new Error("Usage: pie sessions rewind <sessionId> --to <entryId> [--json]");
   const store = new FileSessionStore(getSessionsDir());
-  const data = await store.load(sessionId);
-  if (!data) throw new Error(`Session not found: ${sessionId}`);
-  if (!data.entries.some((entry) => entry.id === entryId)) throw new Error(`Entry not found: ${entryId}`);
-  await store.save(sessionId, data.entries, { ...data.metadata, activeEntryId: entryId, updatedAt: Date.now() });
-  const updated = await store.getMetadata(sessionId);
-  if (!updated) throw new Error(`Session not found after rewind: ${sessionId}`);
+  const result = await rewindStoredSession({ store, sessionId, entryId });
   const response = {
     ok: true,
-    session: sessionSummary(updated),
-    activeEntryId: entryId,
-    currentHead: entryId
+    session: sessionSummary(result.metadata),
+    activeEntryId: result.activeEntryId,
+    currentHead: result.headEntryId
   };
   if (json) {
     console.log(JSON.stringify(response, null, 2));
@@ -46720,50 +46878,23 @@ async function forkSession(args) {
     throw new Error("Usage: pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--json]");
   }
   const store = new FileSessionStore(getSessionsDir());
-  const source = await store.load(sourceSessionId);
-  if (!source) throw new Error(`Session not found: ${sourceSessionId}`);
-  if (await store.exists(targetSessionId)) throw new Error(`Target session already exists: ${targetSessionId}`);
-  const pathEntries = pathToEntry(source, sourceEntryId);
-  if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1]?.id !== sourceEntryId) {
-    throw new Error(`Entry not found: ${sourceEntryId}`);
-  }
-  const now = Date.now();
-  const idMap = /* @__PURE__ */ new Map();
-  for (const entry of pathEntries) idMap.set(entry.id, generateEntryId());
-  const forkedEntries = pathEntries.map((entry) => {
-    const nextId = idMap.get(entry.id);
-    if (!nextId) throw new Error(`Failed to map entry: ${entry.id}`);
-    const parentId = entry.parentId ? idMap.get(entry.parentId) ?? null : null;
-    return {
-      ...cloneJson(entry),
-      id: nextId,
-      parentId,
-      timestamp: entry.timestamp
-    };
-  });
-  const activeEntryId = idMap.get(sourceEntryId) ?? null;
-  await store.save(targetSessionId, forkedEntries, {
-    name,
-    createdAt: now,
-    updatedAt: now,
-    activeEntryId,
-    cwd: cwd ?? source.metadata.cwd,
+  const result = await forkStoredSession({
+    store,
     sourceSessionId,
     sourceEntryId,
-    sourceActiveEntryId: source.metadata.activeEntryId ?? void 0,
-    forkBaseEntryId: activeEntryId ?? void 0
+    targetSessionId,
+    name,
+    cwd
   });
-  const updated = await store.getMetadata(targetSessionId);
-  if (!updated) throw new Error(`Session not found after fork: ${targetSessionId}`);
   const response = {
     ok: true,
-    session: sessionSummary(updated),
+    session: sessionSummary(result.metadata),
     sourceSessionId,
     sourceEntryId,
-    sourceActiveEntryId: source.metadata.activeEntryId,
-    forkBaseEntryId: activeEntryId,
-    activeEntryId,
-    currentHead: activeEntryId
+    sourceActiveEntryId: result.sourceActiveEntryId,
+    forkBaseEntryId: result.forkBaseEntryId,
+    activeEntryId: result.targetActiveEntryId,
+    currentHead: result.targetHeadEntryId
   };
   if (json) {
     console.log(JSON.stringify(response, null, 2));
@@ -46856,7 +46987,7 @@ function activeTranscriptEvents(entries) {
       role,
       turnId,
       content: textFromMessage(entry.message),
-      message: entry.message ? cloneJson(entry.message) : void 0
+      message: entry.message ? cloneJson2(entry.message) : void 0
     };
   });
 }
@@ -46879,18 +47010,6 @@ function activePathEntries(data) {
   if (!activeEntryId) return [];
   return pathToEntry(data, activeEntryId);
 }
-function pathToEntry(data, entryId) {
-  const byId = new Map(data.entries.map((entry) => [entry.id, entry]));
-  const path31 = [];
-  let current = entryId;
-  while (current) {
-    const entry = byId.get(current);
-    if (!entry) return [];
-    path31.unshift(entry);
-    current = entry.parentId;
-  }
-  return path31;
-}
 function resolveBeforeCursor(events, cursor) {
   if (!cursor) return events.length;
   const numeric = Number(cursor);
@@ -46900,7 +47019,7 @@ function resolveBeforeCursor(events, cursor) {
   const index = events.findIndex((event) => event.entryId === cursor || event.checkpointId === cursor);
   return index >= 0 ? index : events.length;
 }
-function cloneJson(value) {
+function cloneJson2(value) {
   return JSON.parse(JSON.stringify(value));
 }
 function listCursorQueryKey(input) {
@@ -59939,7 +60058,14 @@ var ExecutionStateManager = class {
     return this.store.clear();
   }
   restoreFromMetadata(raw) {
-    return this.store.replace(restoreExecutionState(raw));
+    const restored = restoreExecutionState(raw);
+    if (restored.mode === "todo" && restored.lifecycle === "active" && restored.awaitingContinuation) {
+      return this.store.replace(pauseExecutionState({
+        ...restored,
+        awaitingContinuation: false
+      }, "Previous todo turn was interrupted while a tool was running. Send 'continue' to resume the remaining items."));
+    }
+    return this.store.replace(restored);
   }
   getReminder() {
     return buildExecutionReminder(this.store.read());
@@ -67872,6 +67998,14 @@ function scheduleContinuationTimeout(host) {
       });
       return;
     }
+    if (host.agent.state.isStreaming || host.isProcessing || host.submitLock || host.pendingTools.size > 0) {
+      host.logDebug("continuation_timeout:active_work", {
+        isStreaming: host.agent.state.isStreaming,
+        isProcessing: host.isProcessing,
+        pendingTools: host.pendingTools.size
+      });
+      return;
+    }
     const outcome = host.executionState.markAwaitingContinuationStalled();
     host.logDebug("continuation_timeout:expired", {
       currentStepId: state.currentStepId,
@@ -67886,20 +68020,6 @@ function scheduleContinuationTimeout(host) {
         appendWarningSummary(host, outcome.terminalSummary);
       }
     }
-    if (host.agent.state.isStreaming || host.submitLock || host.isProcessing) {
-      host.logDebug("continuation_timeout:force_reset", {
-        isStreaming: host.agent.state.isStreaming,
-        submitLock: host.submitLock,
-        isProcessing: host.isProcessing
-      });
-      host.agent.resetProcessingState();
-      host.isProcessing = false;
-      host.setSubmitLock(false);
-      host.streamingComponent = void 0;
-      host.pendingTools.clear();
-      host.footer.setState({ status: "ready" });
-      host.safeRequestRender();
-    }
     host.agentSessionController?.requestQueueDispatch();
   }, timeoutMs);
 }
@@ -68230,7 +68350,7 @@ function buildRuntimeModeContext(state) {
   const lines = [
     RUNTIME_MODE_CONTEXT_MARKER,
     "Current runtime mode:",
-    `- Plan mode: ${state.planMode === "planning" ? "active (analysis/read-only planning)" : "off"}.`,
+    `- Plan mode: ${state.planMode === "planning" ? "active (workspace read-only; plan_scratch permits session-local temporary drafts)" : "off"}.`,
     `- YOLO mode: ${state.yoloMode ? "on (filesystem sandbox directory restrictions are disabled)" : "off (workspace/protected-path restrictions apply)"}.`,
     `- Filesystem scope: ${state.filesystemScope === "all" ? "all local paths may be passed directly to file tools when permitted" : "workspace paths and configured safe roots only"}.`
   ];
@@ -68238,7 +68358,7 @@ function buildRuntimeModeContext(state) {
     const transitionText = {
       entered_yolo: "YOLO mode was just enabled for this turn.",
       exited_yolo: "YOLO mode was just disabled; do not assume previous absolute-path access still applies.",
-      entered_plan: "Plan mode was just enabled; analyze and plan without making changes.",
+      entered_plan: "Plan mode was just enabled; analyze and plan without changing the workspace. Use plan_scratch for temporary drafts.",
       exited_plan: "Plan mode was just disabled; execution tools may be used when the task requires them."
     };
     lines.push(`- Transition: ${transitionText[state.pendingTransition]}`);
@@ -69240,7 +69360,10 @@ var InteractiveMode = class {
   async syncSessionScopedState(messages) {
     const activeSession = this.sessionManager.getActiveSession();
     const sessionMessages = messages ?? this.sessionManager.getMessages();
-    this.executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+    const restoredExecutionState = this.executionState.restoreFromMetadata(activeSession?.metadata?.executionState);
+    if (restoredExecutionState.lifecycle === "paused" && activeSession?.metadata?.executionState?.awaitingContinuation) {
+      this.persistExecutionState();
+    }
     if (this.executionState.clearIfSupersededByUserMessage(sessionMessages)) {
       this.persistExecutionState();
     }
@@ -69257,7 +69380,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-27UD2ZBZ.js");
+    const { Agent } = await import("./chunks/src-PBRYPFUI.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -69978,7 +70101,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-27UD2ZBZ.js");
+  const { Agent: AgentClass } = await import("./chunks/src-PBRYPFUI.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -70224,6 +70347,26 @@ function parseInput(line) {
       reason: typeof parsed.reason === "string" ? parsed.reason : void 0
     };
   }
+  if (parsed.type === "session.rewind") {
+    return {
+      type: "session.rewind",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      requestId: typeof parsed.requestId === "string" ? parsed.requestId : void 0,
+      entryId: typeof parsed.entryId === "string" ? parsed.entryId : void 0,
+      checkpointId: typeof parsed.checkpointId === "string" ? parsed.checkpointId : void 0
+    };
+  }
+  if (parsed.type === "session.fork") {
+    return {
+      type: "session.fork",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      requestId: typeof parsed.requestId === "string" ? parsed.requestId : void 0,
+      fromEntryId: typeof parsed.fromEntryId === "string" ? parsed.fromEntryId : void 0,
+      targetSessionId: typeof parsed.targetSessionId === "string" ? parsed.targetSessionId : void 0,
+      name: typeof parsed.name === "string" ? parsed.name : void 0,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0
+    };
+  }
   if ((parsed.type === "turn.request" || parsed.type === "turn.input") && typeof parsed.turnId === "string" && typeof parsed.prompt === "string") {
     const streamingBehavior = parsed.streamingBehavior;
     if (streamingBehavior !== void 0 && streamingBehavior !== "steer" && streamingBehavior !== "followUp") {
@@ -70386,6 +70529,7 @@ async function runJsonEventsMode(params) {
   let thinkingLevel = "off";
   let defaultRuntime;
   let defaultModelState;
+  const completedSessionControlRequests = /* @__PURE__ */ new Map();
   const noProgressTimeoutMs = Number(process.env.PIE_JSON_EVENTS_NO_PROGRESS_MS || 6e5);
   const mockResponseDelayMs = Number(process.env.PIE_TEST_MOCK_RESPONSE_DELAY_MS || 0);
   writeEvent({ type: "agent.ready", sessionId });
@@ -70534,6 +70678,148 @@ async function runJsonEventsMode(params) {
     }
     return error instanceof Error ? error.message : String(error);
   }
+  function sessionControlStore() {
+    return new FileSessionStore(runtime?.paths.sessionsDir ?? getSessionsDir());
+  }
+  function invalidSessionControl(message) {
+    return new SessionControlError("invalid_request", message);
+  }
+  function requireSessionControlString(value, field) {
+    const normalized = value?.trim();
+    if (!normalized) {
+      throw invalidSessionControl(`${field} is required`);
+    }
+    return normalized;
+  }
+  function requireSessionControlBase(message) {
+    const requestedSessionId = requireSessionControlString(message.sessionId, "sessionId");
+    const requestId = requireSessionControlString(message.requestId, "requestId");
+    if (requestedSessionId !== sessionId) {
+      throw new SessionControlError("session_mismatch", sessionMismatchError(requestedSessionId), false);
+    }
+    if (activeTurn && !activeTurn.finalized) {
+      throw new SessionControlError("session_busy", `Cannot ${message.type.slice("session.".length)} session while a turn is active`);
+    }
+    return { sessionId: requestedSessionId, requestId };
+  }
+  function resolveRewindEntryId(message) {
+    const entryId = message.entryId?.trim();
+    const checkpointId = message.checkpointId?.trim();
+    if (entryId && checkpointId && entryId !== checkpointId) {
+      throw invalidSessionControl("entryId and checkpointId must match when both are provided");
+    }
+    const resolved = entryId || checkpointId;
+    if (!resolved) {
+      throw invalidSessionControl("entryId or checkpointId is required");
+    }
+    return resolved;
+  }
+  function writeSessionControlFailure(message, operation, error) {
+    const detail = error instanceof SessionControlError ? error : new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+    writeEvent({
+      type: "session.failed",
+      sessionId: message.sessionId || sessionId,
+      requestId: message.requestId,
+      operation,
+      error: detail.message,
+      code: detail.code,
+      recoverable: detail.recoverable
+    });
+  }
+  async function saveRuntimeSessionForControl() {
+    if (!runtime?.sessionManager.getActiveSession()) return;
+    try {
+      await runtime.sessionManager.save();
+    } catch (error) {
+      throw new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function syncRuntimeAfterRewind(controlSessionId) {
+    if (params.mockResponse !== void 0) return;
+    if (runtime?.sessionManager.getActiveSessionId() !== controlSessionId) return;
+    const loaded = await runtime.sessionManager.loadSession(controlSessionId, { warnIfMissing: false });
+    if (!loaded) {
+      const exists = await runtime.sessionManager.hasSession(controlSessionId);
+      throw new SessionControlError(
+        exists ? "session_unrecoverable" : "session_not_found",
+        exists ? `Session could not be recovered: ${controlSessionId}` : `Session not found: ${controlSessionId}`,
+        !exists
+      );
+    }
+    controller?.syncFromActiveSession();
+  }
+  async function handleSessionRewind(message) {
+    try {
+      const { sessionId: controlSessionId, requestId } = requireSessionControlBase(message);
+      const cached = completedSessionControlRequests.get(requestId);
+      if (cached) {
+        writeEvent(cached);
+        return;
+      }
+      const entryId = resolveRewindEntryId(message);
+      await saveRuntimeSessionForControl();
+      const result = await rewindStoredSession({
+        store: sessionControlStore(),
+        sessionId: controlSessionId,
+        entryId
+      });
+      await syncRuntimeAfterRewind(controlSessionId);
+      mockActiveEntryId = result.headEntryId;
+      const event = {
+        type: "session.rewound",
+        sessionId: controlSessionId,
+        requestId,
+        entryId: result.entryId,
+        checkpointId: result.checkpointId,
+        headEntryId: result.headEntryId,
+        activeEntryId: result.activeEntryId
+      };
+      completedSessionControlRequests.set(requestId, event);
+      writeEvent(event);
+    } catch (error) {
+      writeSessionControlFailure(message, "rewind", error);
+    }
+  }
+  async function handleSessionFork(message) {
+    try {
+      const { sessionId: controlSessionId, requestId } = requireSessionControlBase(message);
+      const sourceEntryId = requireSessionControlString(message.fromEntryId, "fromEntryId");
+      const targetSessionId = requireSessionControlString(message.targetSessionId, "targetSessionId");
+      const name = requireSessionControlString(message.name, "name");
+      const forkCwd = message.cwd?.trim() || void 0;
+      const cached = completedSessionControlRequests.get(requestId);
+      if (cached) {
+        writeEvent(cached);
+        return;
+      }
+      await saveRuntimeSessionForControl();
+      const result = await forkStoredSession({
+        store: sessionControlStore(),
+        sourceSessionId: controlSessionId,
+        sourceEntryId,
+        targetSessionId,
+        name,
+        cwd: forkCwd,
+        requestId
+      });
+      const event = {
+        type: "session.forked",
+        sessionId: controlSessionId,
+        requestId,
+        sourceSessionId: result.sourceSessionId,
+        sourceEntryId: result.sourceEntryId,
+        sourceCheckpointId: result.sourceCheckpointId,
+        targetSessionId: result.targetSessionId,
+        targetHeadEntryId: result.targetHeadEntryId,
+        targetActiveEntryId: result.targetActiveEntryId,
+        headEntryId: result.headEntryId
+      };
+      completedSessionControlRequests.set(requestId, event);
+      writeEvent(event);
+    } catch (error) {
+      writeSessionControlFailure(message, "fork", error);
+    }
+  }
   function finalize(kind, detail) {
     const turn = activeTurn;
     if (!turn || turn.finalized) return;
@@ -70765,7 +71051,7 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-27UD2ZBZ.js");
+    const { Agent: AgentClass } = await import("./chunks/src-PBRYPFUI.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
     recordCliCompositionStep(runtime.compositionTrace, {
@@ -71169,6 +71455,14 @@ async function runJsonEventsMode(params) {
       await interrupt(message);
       continue;
     }
+    if (message.type === "session.rewind") {
+      await handleSessionRewind(message);
+      continue;
+    }
+    if (message.type === "session.fork") {
+      await handleSessionFork(message);
+      continue;
+    }
     const shouldTrackTurn = !activeTurn || activeTurn.finalized;
     const turnPromise = runTurn(message).catch((error) => {
       writeEvent({
@@ -71389,7 +71683,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-L4PUYWQQ.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-EO6L26M5.js")).createTestStreamFnFromSequenceEnv();
 }
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");