@xingular/harness 1.2.0 → 1.3.1-unstable.0

package/dist/terminal-pi.js

@@ -1,5 +1,5 @@
 // src/terminal/piExtension.ts
-import { createBashTool, createEditTool, createWriteTool } from "@earendil-works/pi-coding-agent";
+import { createBashTool, createEditTool, createPowerShellTool, createWriteTool } from "@earendil-works/pi-coding-agent";
 import { Type as Type2 } from "typebox";
 
 // src/terminal/client.ts
@@ -199,6 +199,8 @@ var runEventTypeSchema = z.enum([
   "extension.notice",
   "reaction.added",
   "agent.message",
+  "todo.updated",
+  // Written before the rename; accepted so stored run logs keep their lists. Never written now.
   "checklist.updated",
   "checkpoint",
   "heartbeat",
@@ -336,9 +338,9 @@ var extensionNoticePayload = z.object({
   text: z.string(),
   extension: z.string().optional()
 });
-var checklistItemSchema = z.object({ text: z.string().min(1).max(500), status: z.enum(["pending", "in_progress", "completed"]) }).strict();
-var MAX_CHECKLIST_ITEMS = 50;
-var checklistPayload = z.object({ items: z.array(checklistItemSchema).max(MAX_CHECKLIST_ITEMS) }).strict();
+var todoItemSchema = z.object({ text: z.string().min(1).max(500), status: z.enum(["pending", "in_progress", "completed"]) }).strict();
+var MAX_TODO_ITEMS = 50;
+var todoPayload = z.object({ items: z.array(todoItemSchema).max(MAX_TODO_ITEMS) }).strict();
 var MAX_CHECKPOINT_SUMMARY = 1200;
 var MAX_CHECKPOINT_DONE = 20;
 var MAX_CHECKPOINT_EVIDENCE = 5;
@@ -469,7 +471,8 @@ var runEventPayloadSchemas = {
   "extension.notice": extensionNoticePayload,
   "reaction.added": reactionAddedPayload,
   "agent.message": agentMessagePayload,
-  "checklist.updated": checklistPayload,
+  "todo.updated": todoPayload,
+  "checklist.updated": todoPayload,
   checkpoint: checkpointPayload,
   heartbeat: heartbeatPayload,
   "artifact.added": artifactPayload,
@@ -526,7 +529,9 @@ var runRecordSchema = z.object({
   variantScope: text.optional(),
   variantVersion: text.optional(),
   profile: text.optional(),
-  title: text.optional()
+  title: text.optional(),
+  model: text.optional(),
+  effort: text.optional()
 });
 
 // src/core/index.ts
@@ -565,7 +570,7 @@ var PLAN_RESEARCH_TOOLS = /* @__PURE__ */ new Set([
   "grep",
   "find",
   "ls",
-  "checklist_write",
+  "todo_write",
   "session_name",
   "history_search",
   "history_read",
@@ -653,38 +658,39 @@ function askUserTool(run2) {
   };
 }
 
-// src/tools/checklist.ts
-var CHECKLIST_WRITE = "checklist_write";
+// src/tools/todo.ts
+var TODO_WRITE = "todo_write";
+var TODO_GUIDANCE = "If the work has several distinct steps or will take more than one tool call, call todo_write before your first other tool call with the steps you know so far, and keep the list current as steps start and finish. Before your final reply, write one final update: mark every fully completed step completed and leave unfinished or blocked steps accurate. Never mark unfinished work completed. The person follows your work from it, and a subagent\u2019s todo list shows as its progress in the person\u2019s list of subagents.";
 var MARK = { pending: "[ ]", in_progress: "[~]", completed: "[x]" };
-function describeChecklist(items) {
-  if (!items.length) return "The checklist is empty.";
+function describeTodo(items) {
+  if (!items.length) return "The todo list is empty.";
   return items.map((item) => `${MARK[item.status]} ${item.text}`).join("\n");
 }
-function checklistTool(run2) {
+function todoTool(run2) {
   return {
-    name: CHECKLIST_WRITE,
-    label: "Write the checklist",
-    description: "Keep a checklist of the steps of the current work. The user watches this list to follow your progress, so write it early and keep it current. Send the whole list every time; it replaces the previous one. Use it whenever the work has several distinct steps or will take several tool calls, when the user gives several things to do, and when a subagent brief asks for more than one thing. Do not use it for a single, simple step or for conversation. Statuses: pending, in_progress, completed. Keep exactly one step in_progress while you work, mark a step completed as soon as it is done (not in batches), and add steps you discover. Before your final response, write one final checklist update: mark every fully completed step completed, and leave unfinished or blocked steps in their accurate pending or in_progress status. Never mark unfinished work completed. Only mark a step completed when it is fully done; if something blocks it, keep it in_progress and add a step for the blocker.",
+    name: TODO_WRITE,
+    label: "Write the todo list",
+    description: `Keep a todo list of the steps of the current work. The user watches this list to follow your progress. ${TODO_GUIDANCE} Send the whole list every time; it replaces the previous one. Do not use it for a single, simple step or for conversation. Statuses: pending, in_progress, completed. Keep exactly one step in_progress while you work, mark a step completed as soon as it is done (not in batches), and add steps you discover. Only mark a step completed when it is fully done; if something blocks it, keep it in_progress and add a step for the blocker.`,
     parameters: (Type3) => Type3.Object({
       items: Type3.Array(Type3.Object({
         text: Type3.String({ description: "One step, as a short imperative line" }),
         status: Type3.Union([Type3.Literal("pending"), Type3.Literal("in_progress"), Type3.Literal("completed")])
-      }), { maxItems: MAX_CHECKLIST_ITEMS })
+      }), { maxItems: MAX_TODO_ITEMS })
     }),
     readOnly: true,
     planModeSafe: () => true,
     execute: async (input) => {
-      if (!Array.isArray(input.items)) return "Send items: the whole checklist as an array.";
-      if (input.items.length > MAX_CHECKLIST_ITEMS) return `Keep the checklist to ${MAX_CHECKLIST_ITEMS} steps or fewer.`;
+      if (!Array.isArray(input.items)) return "Send items: the whole todo list as an array.";
+      if (input.items.length > MAX_TODO_ITEMS) return `Keep the todo list to ${MAX_TODO_ITEMS} steps or fewer.`;
       const items = [];
       for (const raw of input.items) {
         const entry = raw;
-        const parsed = checklistItemSchema.safeParse({ text: typeof entry?.text === "string" ? entry.text.trim() : entry?.text, status: entry?.status });
+        const parsed = todoItemSchema.safeParse({ text: typeof entry?.text === "string" ? entry.text.trim() : entry?.text, status: entry?.status });
         if (!parsed.success) return "Every step needs text of 1 to 500 characters and a status of pending, in_progress or completed.";
         items.push(parsed.data);
       }
-      run2.emit("checklist.updated", { items });
-      return describeChecklist(items);
+      run2.emit("todo.updated", { items });
+      return describeTodo(items);
     }
   };
 }
@@ -798,14 +804,15 @@ function checkpointTool(run2, slice) {
 import { createHash } from "node:crypto";
 var DEFAULT_SLICE_POLICY = {
   enabled: true,
-  // Roughly 40 minutes of ordinary work (about 15 s a call), so a checkpoint is a chapter of a
-  // task, not an interruption every few edits. A task still gets eight of them before the cap.
-  maxToolCalls: 160,
-  maxMinutes: 40,
-  // A generous cost ceiling, counted on new input, cache writes and output only: heavy reading at
-  // a large context can add tens of thousands of tokens a request, so a small cap stopped useful
-  // work (see the "Confirm plan model support" thread). 320k is a safety net, not the bound.
-  maxNewTokens: 32e4,
+  // A chapter of a task, not an interruption every few edits: roughly 80 minutes of ordinary work
+  // (about 15 s a call), with 60 minutes of wall clock as the ceiling, whichever comes first. A task
+  // still gets eight slices before it returns to the person.
+  maxToolCalls: 320,
+  maxMinutes: 60,
+  // No token cap: the tool calls and the clock are the bound. Counting new input, cache writes and
+  // output made a few large reads end a reply before useful work (see the "Confirm plan model
+  // support" thread), so a cap is available to whoever asks for one and off unless they do.
+  maxNewTokens: 0,
   maxSlices: 8,
   continue: true
 };
@@ -884,42 +891,54 @@ function canonical(value, depth = 0) {
 }
 var signature = (name, input) => `${name}\0${createHash("sha256").update(canonical(input ?? null)).digest("hex")}`;
 var clip = (value, limit) => value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
-function handoffRequest(limit, state) {
-  return clip(
-    `This reply reached its work-slice limit (${limit}; step ${state.steps}). Call checkpoint_write now with what is done, the single next step, anything blocking, the files you touched and the checks that matter. Then tell the user in a few lines where you stopped. Do not call other tools.`,
-    600
-  );
-}
-function stalledNote(reason) {
-  return clip(
-    `You are repeating work: ${reason}. Do not repeat it. Choose a different approach, read what the earlier attempt returned, or call checkpoint_write with the blocker so the next slice can decide.`,
-    600
-  );
+function handoffRequest(limit, state, checkpointAvailable = true) {
+  const handoff = checkpointAvailable ? "Call checkpoint_write now with what is done, the single next step, anything blocking, the files you touched and the checks that matter. Then tell the user in a few lines where you stopped." : "Stop using tools and return a concise partial research report with findings, blockers and the next useful research step. The Harness records an evidence-derived checkpoint.";
+  return clip(`This reply reached its work-slice limit (${limit}; step ${state.steps}). ${handoff} Do not call other tools.`, 600);
+}
+function stalledNote(reason, checkpointAvailable = true) {
+  const handoff = checkpointAvailable ? "Choose a different approach, read what the earlier attempt returned, or call checkpoint_write with the blocker so the next slice can decide." : "Do not use more tools. Return concise findings and blockers in your final response; the Harness records an evidence-derived checkpoint.";
+  return clip(`You are repeating work: ${reason}. Do not repeat it. ${handoff}`, 600);
 }
 function workSliceGuard(options) {
   const { policy, state } = options;
   const calls = /* @__PURE__ */ new Map();
+  const checkCalls = /* @__PURE__ */ new Set();
   const edits = /* @__PURE__ */ new Map();
   const failures = /* @__PURE__ */ new Map();
-  let stepsSinceProgress = 0;
   let nudged = false;
+  const checkpointAvailable = () => typeof options.checkpointAvailable === "function" ? options.checkpointAvailable() : options.checkpointAvailable !== false;
   const resetRepetition = () => {
     calls.clear();
+    checkCalls.clear();
     edits.clear();
     failures.clear();
-    stepsSinceProgress = 0;
     nudged = false;
   };
   const end = (kind, limit) => {
     state.endedBy = kind;
     state.endedByLimit = limit;
     options.onEnd?.(kind, limit);
-    const reason = kind === "stuck" ? stalledNote(limit) : kind === "compaction-thrash" ? handoffRequest("three context compactions in one reply", state) : handoffRequest(limit, state);
+    const canCheckpoint = checkpointAvailable();
+    const reason = kind === "stuck" ? stalledNote(limit, canCheckpoint) : kind === "compaction-thrash" ? handoffRequest("three context compactions in one reply", state, canCheckpoint) : handoffRequest(limit, state, canCheckpoint);
     return { block: true, terminate: true, reason };
   };
+  const nudge = (reason) => {
+    if (nudged) return end("stuck", reason);
+    nudged = true;
+    const canCheckpoint = checkpointAvailable();
+    if (!canCheckpoint) {
+      state.endedBy = "stuck";
+      state.endedByLimit = reason;
+    }
+    return { block: true, reason: stalledNote(reason, canCheckpoint) };
+  };
   const repeated = (name, input) => {
     if (POLLING_TOOLS.has(name)) return null;
     const key = signature(name, input);
+    if (name === "bash") {
+      const command = input && typeof input === "object" ? String(input.command ?? "") : "";
+      if (command && looksLikeCheck(command)) checkCalls.add(key);
+    }
     const count = (calls.get(key) ?? 0) + 1;
     calls.set(key, count);
     if (count < 3) return null;
@@ -945,9 +964,18 @@ function workSliceGuard(options) {
     pi.on("tool_result", (event) => {
       if (event.toolName === "checkpoint_write" && !event.isError) {
         state.checkpointWritten = true;
-        stepsSinceProgress = 0;
         nudged = false;
       }
+      if ((event.toolName === "edit" || event.toolName === "write") && event.isError === false) {
+        const path = event.input && typeof event.input === "object" ? String(event.input.path ?? "") : "";
+        if (path) {
+          edits.set(path, (edits.get(path) ?? 0) + 1);
+          failures.clear();
+          for (const key of checkCalls) calls.delete(key);
+          checkCalls.clear();
+          nudged = false;
+        }
+      }
       if (event.toolName !== "bash") return;
       const command = event.input && typeof event.input === "object" ? String(event.input.command ?? "") : "";
       if (!command || !looksLikeCheck(command)) return;
@@ -958,16 +986,18 @@ function workSliceGuard(options) {
       failures.delete(command);
       edits.clear();
       calls.clear();
-      stepsSinceProgress = 0;
+      checkCalls.clear();
       nudged = false;
     });
     pi.on("tool_call", (event) => {
       const name = event.toolName;
       state.steps += 1;
       state.lastTool = name;
-      const handoff = HANDOFF_TOOLS.has(name);
+      const canCheckpoint = checkpointAvailable();
+      const handoff = canCheckpoint && HANDOFF_TOOLS.has(name);
       if (state.endedBy) {
-        return handoff ? void 0 : { block: true, terminate: true, reason: "This reply is over. Its checkpoint is recorded; nothing else runs." };
+        const reason2 = state.checkpointWritten ? "This reply is over. Its checkpoint is recorded; nothing else runs." : "This reply is over. The Harness will record an evidence-derived checkpoint; nothing else runs.";
+        return handoff ? void 0 : { block: true, terminate: true, reason: reason2 };
       }
       if (state.compactions >= 3) {
         if (handoff) {
@@ -982,34 +1012,24 @@ function workSliceGuard(options) {
         state.endedBy = "budget";
         state.endedByLimit = limit;
         state.refusedAt ??= state.steps;
-        stepsSinceProgress = 0;
-        return handoff ? void 0 : { block: true, reason: handoffRequest(limit, state) };
+        return handoff ? void 0 : { block: true, reason: handoffRequest(limit, state, canCheckpoint) };
       }
       if (handoff) return void 0;
+      if (name === "todo_write") return void 0;
       const edit = name === "edit" || name === "write";
       const path = edit && event.input && typeof event.input === "object" ? String(event.input.path ?? "") : "";
       if (edit && path) {
-        const count = (edits.get(path) ?? 0) + 1;
-        edits.set(path, count);
-        stepsSinceProgress = 0;
+        const count = edits.get(path) ?? 0;
         if (count >= 4) {
           const reason2 = `${path} was edited ${count} times with no passing check between`;
-          if (nudged) return end("stuck", reason2);
-          nudged = true;
-          return { block: true, reason: stalledNote(reason2) };
+          return nudge(reason2);
         }
-      } else {
-        stepsSinceProgress += 1;
       }
       const repeat = repeated(name, event.input);
       const failure = failing(name, event.input);
-      const noProgress = stepsSinceProgress >= 25 ? `${stepsSinceProgress} steps with no file change and no passing check` : null;
-      const reason = repeat ?? failure ?? noProgress;
+      const reason = repeat ?? failure;
       if (!reason) return void 0;
-      if (nudged) return end("stuck", reason);
-      nudged = true;
-      stepsSinceProgress = 0;
-      return { block: true, reason: stalledNote(reason) };
+      return nudge(reason);
     });
   };
 }
@@ -1058,11 +1078,12 @@ async function withCommandBudget(run2, abort, seconds) {
 
 // src/tools/sessionName.ts
 var SESSION_NAME = "session_name";
+var SESSION_GUIDANCE = "If the request needs tools or changes state \u2014 not a greeting, thanks, or a short conversational reply \u2014 call session_name once before your first other tool call, naming the work from the request. Use one short imperative sentence of at most six words. Revise the name only when the overall objective changes; keep the current name when it does not.";
 function sessionNameTool(current) {
   return {
     name: SESSION_NAME,
     label: "Name the session",
-    description: 'Set or revise this session\u2019s name. Name meaningful work early, then revise the name when the overall objective changes; greetings alone need no name. Use one short imperative sentence describing the objective, at most six words, such as "Add web browser integrations". You may revise a manually assigned name. Keep a useful current name when the objective is unchanged. This only names your own session.',
+    description: `Set or revise this session\u2019s name. ${SESSION_GUIDANCE} For example, "Add web browser integrations". You may revise a manually assigned name. This only names your own session.`,
     parameters: (Type3) => Type3.Object({ name: Type3.String({ description: "One short sentence describing the objective, at most six words" }) }),
     planModeSafe: () => true,
     execute: async (input) => {
@@ -1123,7 +1144,7 @@ function clip2(text4, limit) {
   return charCount(text4) <= limit ? text4 : `${takeChars(text4, limit)}\u2026`;
 }
 function renderCompactionCheckpoint(input) {
-  if (!input.checklist.length && !input.planInstructions) return null;
+  if (!input.todo.length && !input.planInstructions) return null;
   const parts = [
     "This is current state from the active run after context compaction, not a new user request. Continue the same request. Do not infer that omitted details or decisions were settled.",
     input.goal.trim() ? `## Current request
@@ -1133,18 +1154,18 @@ ${clip2(input.goal.trim(), 1e3)}` : "",
 
 ${clip2(input.planInstructions, 4e3)}` : ""
   ].filter(Boolean);
-  if (input.checklist.length) {
-    const active = input.checklist.filter((item) => item.status !== "completed");
-    const completed = input.checklist.filter((item) => item.status === "completed");
-    const checklist = [
+  if (input.todo.length) {
+    const active = input.todo.filter((item) => item.status !== "completed");
+    const completed = input.todo.filter((item) => item.status === "completed");
+    const todo = [
       active.length ? `### In progress and pending
-${clip2(describeChecklist(active), 2500)}` : "",
+${clip2(describeTodo(active), 2500)}` : "",
       completed.length ? `### Completed (${completed.length})
-${clip2(describeChecklist(completed), 500)}` : ""
+${clip2(describeTodo(completed), 500)}` : ""
     ].filter(Boolean).join("\n\n");
-    parts.push(`## Current checklist
+    parts.push(`## Current todo list
 
-${checklist}`);
+${todo}`);
   }
   const body = clip2(parts.join("\n\n"), 8e3);
   return `[Harness context update \u2014 not a user message]
@@ -1165,7 +1186,7 @@ var PLAN_READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
   "find",
   "ls",
   SESSION_NAME,
-  CHECKLIST_WRITE,
+  TODO_WRITE,
   ASK_USER,
   "ask_user_question",
   GET_CAPABILITIES,
@@ -1264,12 +1285,12 @@ function planRefusal(tool, readOnly, args, planModeSafe) {
 
 // src/sessions/compactionCheckpoint.ts
 var COMPACTION_CHECKPOINT_EXTENSION = "compaction-checkpoint";
-function validatedChecklist(value) {
-  if (!Array.isArray(value) || value.length > MAX_CHECKLIST_ITEMS) return null;
+function validatedTodo(value) {
+  if (!Array.isArray(value) || value.length > MAX_TODO_ITEMS) return null;
   const items = [];
   for (const valueItem of value) {
     const item = valueItem;
-    const parsed = checklistItemSchema.safeParse({
+    const parsed = todoItemSchema.safeParse({
       text: typeof item?.text === "string" ? item.text.trim() : item?.text,
       status: item?.status
     });
@@ -1281,26 +1302,26 @@ function validatedChecklist(value) {
 function compactionCheckpoint(options = {}) {
   return (pi) => {
     let goal = "";
-    let checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+    let todo = validatedTodo(options.initialTodo ?? []) ?? [];
     let lastCompactionKey = null;
     let compacted = false;
     const reset = () => {
       goal = "";
-      checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+      todo = validatedTodo(options.initialTodo ?? []) ?? [];
       lastCompactionKey = null;
       compacted = false;
     };
     pi.on("before_agent_start", (event) => {
       if (event.messageType !== "user") return;
       goal = event.prompt;
-      checklist = validatedChecklist(options.initialChecklist ?? []) ?? [];
+      todo = validatedTodo(options.initialTodo ?? []) ?? [];
       lastCompactionKey = null;
       compacted = false;
     });
     pi.on("tool_result", (event) => {
-      if (event.toolName !== CHECKLIST_WRITE || event.isError) return;
-      const items = validatedChecklist(event.input.items);
-      if (items) checklist = items;
+      if (event.toolName !== TODO_WRITE || event.isError) return;
+      const items = validatedTodo(event.input.items);
+      if (items) todo = items;
     });
     pi.on("context", (event) => {
       const summary = event.messages.findLast((message) => message.role === "compactionSummary");
@@ -1314,7 +1335,7 @@ function compactionCheckpoint(options = {}) {
         compacted = false;
       }
       if (!compacted) return;
-      const content = renderCompactionCheckpoint({ goal, checklist, planInstructions });
+      const content = renderCompactionCheckpoint({ goal, todo, planInstructions });
       if (!content) return;
       return {
         messages: [...event.messages, {
@@ -1428,23 +1449,150 @@ function inspectWorkspaceWrite(workspaceRoot, cwd, tool, input) {
 // src/core/workspaceBashTool.ts
 import { Type } from "typebox";
 
+// src/core/shell.ts
+import { accessSync as accessSync2, constants as constants2, statSync as statSync3 } from "node:fs";
+import { win32 } from "node:path";
+
+// src/core/path.ts
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, statSync as statSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, extname, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+var resolved = null;
+function searchPath() {
+  const platform = process.platform;
+  const pathKey = pathVariableName(process.env);
+  const inherited = process.env[pathKey] ?? "";
+  if (resolved?.platform === platform && resolved.inherited === inherited) return resolved.path;
+  const separator = pathSeparator(platform);
+  const entries = [];
+  if (platform !== "win32") {
+    try {
+      const output = execFileSync(process.env.SHELL || "/bin/zsh", ["-ilc", 'printf %s "$PATH"'], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
+      entries.push(...(output.split("\n").filter(Boolean).at(-1) ?? "").split(separator));
+    } catch {
+    }
+  }
+  entries.push(...inherited.split(separator));
+  if (platform !== "win32") {
+    const home = homedir2();
+    if (home) entries.push(...[".local/bin", ".bun/bin", ".npm-global/bin", ".cargo/bin"].map((folder) => join2(home, folder)));
+    entries.push("/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin");
+  }
+  const path = [...new Set(entries.filter(Boolean))].join(separator);
+  resolved = { platform, inherited, path };
+  return path;
+}
+function pathVariableName(environment) {
+  return Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
+}
+function pathSeparator(platform) {
+  return platform === "win32" ? ";" : delimiter;
+}
+function isExecutable(path) {
+  try {
+    accessSync(path, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+    return statSync2(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function findBinary(name) {
+  const platform = process.platform;
+  const suffixes = platform === "win32" && !extname(name) ? (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [];
+  const names = [name, ...suffixes.map((suffix) => `${name}${suffix}`)];
+  if (isAbsolute2(name)) {
+    for (const candidate of names) if (isExecutable(candidate)) return candidate;
+    return null;
+  }
+  for (const directory of searchPath().split(pathSeparator(platform))) {
+    for (const candidateName of names) {
+      const candidate = join2(directory, candidateName);
+      if (isExecutable(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/core/shell.ts
+var POWERSHELL_ARGS = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command"];
+var POWERSHELL_UTF8 = "try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}\n";
+var cached;
+function hostShell() {
+  if (cached === void 0) cached = resolveShell(process.platform);
+  return cached;
+}
+function resolveShell(platform, lookup = {}) {
+  const env = lookup.env ?? process.env;
+  const exists = lookup.exists ?? isFile;
+  const onPath = lookup.onPath ?? findBinary;
+  if (platform !== "win32") {
+    const executable = ["/bin/bash", "/usr/bin/bash"].find((candidate) => exists(candidate));
+    return executable ? { kind: "bash", executable, args: ["-c"] } : null;
+  }
+  const gitBash = [env.ProgramFiles, env["ProgramFiles(x86)"]].filter((folder) => Boolean(folder)).map((folder) => win32.join(folder, "Git", "bin", "bash.exe")).find((candidate) => exists(candidate));
+  if (gitBash) return { kind: "bash", executable: gitBash, args: ["-c"] };
+  const bashOnPath = onPath("bash.exe");
+  if (bashOnPath && !isWslLauncher(bashOnPath, env)) return { kind: "bash", executable: bashOnPath, args: ["-c"] };
+  const existing = (folder, ...parts) => {
+    if (!folder) return null;
+    const candidate = win32.join(folder, ...parts);
+    return exists(candidate) ? candidate : null;
+  };
+  const powershell = onPath("pwsh.exe") ?? existing(env.ProgramFiles, "PowerShell", "7", "pwsh.exe") ?? onPath("powershell.exe") ?? existing(env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return powershell ? { kind: "powershell", executable: powershell, args: POWERSHELL_ARGS } : null;
+}
+function shellArguments(shell, command) {
+  return [...shell.args, shell.kind === "powershell" ? `${POWERSHELL_UTF8}${command}` : command];
+}
+function shellLabel(shell) {
+  if (shell.kind === "powershell") return "PowerShell";
+  return /\\git\\/iu.test(shell.executable) ? "Git Bash" : "Bash";
+}
+function isWslLauncher(path, env) {
+  const normalized = win32.normalize(path).toLowerCase();
+  const systemRoot = env.SystemRoot;
+  if (systemRoot) {
+    return ["System32", "Sysnative"].some((folder) => normalized === win32.join(systemRoot, folder, "bash.exe").toLowerCase());
+  }
+  return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/u.test(normalized);
+}
+function isFile(path) {
+  try {
+    accessSync2(path, constants2.F_OK);
+    return statSync3(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
 // src/core/workspaceSandbox.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { accessSync, constants, existsSync, lstatSync as lstatSync2, mkdtempSync, realpathSync as realpathSync2, readdirSync, rmSync, statSync as statSync2 } from "node:fs";
+import { accessSync as accessSync3, constants as constants3, existsSync, lstatSync as lstatSync2, mkdtempSync, realpathSync as realpathSync2, readdirSync, rmSync, statSync as statSync4 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
+import { spawnSync } from "node:child_process";
 var MARKER_PREFIX = "__XINGULAR_WORKSPACE_SANDBOX_STARTED_";
 var bashWriteScope = new AsyncLocalStorage();
 function runWithWorkspaceWriteScope(scope, action) {
   return bashWriteScope.run(scope, action);
 }
+var WINDOWS_UNSANDBOXED_REASON = "Windows has no workspace write-boundary sandbox, so this command would run without one. It will not run until this one-call request is approved.";
+var SANDBOX_BACKENDS = {
+  darwin: ["/usr/bin/sandbox-exec"],
+  linux: ["/usr/bin/bwrap", "/bin/bwrap"]
+};
+function workspaceSandboxBackend(platform = process.platform) {
+  const candidates = SANDBOX_BACKENDS[platform];
+  return candidates ? systemExecutable(candidates) : null;
+}
 function systemExecutable(candidates) {
   for (const candidate of candidates) {
     try {
-      accessSync(candidate, constants.X_OK);
-      if (statSync2(candidate).isFile()) return candidate;
+      accessSync3(candidate, constants3.X_OK);
+      if (statSync4(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -1455,6 +1603,16 @@ function shellPath() {
   if (!shell) throw new Error("The workspace write-boundary sandbox requires Bash, but no Bash executable was found.");
   return shell;
 }
+function requireShell(resolve3) {
+  const shell = resolve3();
+  if (!shell) {
+    throw new Error(process.platform === "win32" ? "No shell was found: neither Git Bash nor PowerShell is available. Bash was not run." : "No Bash executable was found. Bash was not run.");
+  }
+  return shell;
+}
+function unconfinedCommand(shell, command) {
+  return { executable: shell.executable, args: shellArguments(shell, command), marker: "" };
+}
 function sbplString(value) {
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n")}"`;
 }
@@ -1496,12 +1654,12 @@ ${command}`;
   if (readOnlyTempRoot !== null) return readOnlySandboxCommand(platform, realpathSync2(readOnlyTempRoot), cwd, shell, wrappedCommand, marker);
   const writeRoots = [...new Set([workspaceRoot, ...additionalWriteRoots].map((root) => realpathSync2(root)))].sort((left, right) => left.length - right.length);
   if (platform === "darwin") {
-    const executable = systemExecutable(["/usr/bin/sandbox-exec"]);
+    const executable = workspaceSandboxBackend(platform);
     if (!executable) throw new Error("Workspace write-boundary sandbox unavailable: sandbox-exec was not found. Bash was not run.");
     return { executable, args: ["-p", macSandboxProfile(writeRoots), shell, "-c", wrappedCommand], marker };
   }
   if (platform === "linux") {
-    const executable = systemExecutable(["/usr/bin/bwrap", "/bin/bwrap"]);
+    const executable = workspaceSandboxBackend(platform);
     if (!executable) throw new Error("Workspace write-boundary sandbox unavailable: install bubblewrap (bwrap). Bash was not run.");
     return {
       executable,
@@ -1530,12 +1688,12 @@ ${command}`;
 }
 function readOnlySandboxCommand(platform, tempRoot, cwd, shell, wrappedCommand, marker) {
   if (platform === "darwin") {
-    const executable = systemExecutable(["/usr/bin/sandbox-exec"]);
+    const executable = workspaceSandboxBackend(platform);
     if (!executable) throw new Error("Read-only Bash sandbox unavailable: sandbox-exec was not found. Bash was not run.");
     return { executable, args: ["-p", macReadOnlyProfile(tempRoot), shell, "-c", wrappedCommand], marker };
   }
   if (platform === "linux") {
-    const executable = systemExecutable(["/usr/bin/bwrap", "/bin/bwrap"]);
+    const executable = workspaceSandboxBackend(platform);
     if (!executable) throw new Error("Read-only Bash sandbox unavailable: install bubblewrap (bwrap). Bash was not run.");
     return {
       executable,
@@ -1570,7 +1728,11 @@ function readOnlySandboxCommand(platform, tempRoot, cwd, shell, wrappedCommand,
   throw new Error(`Read-only Bash sandbox unavailable on ${platform}. Bash was not run.`);
 }
 function killProcess(child) {
-  if (child.pid && process.platform !== "win32") {
+  if (child.pid && process.platform === "win32") {
+    spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+    return;
+  }
+  if (child.pid) {
     try {
       process.kill(-child.pid, "SIGKILL");
       return;
@@ -1691,11 +1853,13 @@ function createWorkspaceBashOperations(workspaceRoot, options = {}) {
       const canonicalCwd = realpathSync2(cwd);
       if (!isWithinWorkspace(root, canonicalCwd)) throw new Error("The Bash working directory is outside the active project workspace.");
       const scope = options.workspaceWriteScope?.() ?? bashWriteScope.getStore() ?? "workspace";
+      const platform = options.platform ?? process.platform;
+      const shell = options.shell ?? hostShell;
       if (scope === "read-only") {
-        const platform2 = options.platform ?? process.platform;
-        const tempRoot = realpathSync2(mkdtempSync(join2(tmpdir(), "harness-read-only-bash-")));
+        if (platform === "win32") throw new Error("Plan-mode Bash needs a read-only sandbox, which Windows does not have. Bash was not run.");
+        const tempRoot = realpathSync2(mkdtempSync(join3(tmpdir(), "harness-read-only-bash-")));
         try {
-          const spec2 = workspaceSandboxCommand(platform2, root, canonicalCwd, command, [], tempRoot);
+          const spec2 = workspaceSandboxCommand(platform, root, canonicalCwd, command, [], tempRoot);
           const env = { ...execOptions.env ?? process.env, TMPDIR: tempRoot };
           const result2 = await runProcess(spec2, canonicalCwd, { ...execOptions, env }, spec2.marker);
           return { exitCode: result2.exitCode };
@@ -1710,11 +1874,12 @@ function createWorkspaceBashOperations(workspaceRoot, options = {}) {
         bypass = false;
       }
       if (bypass) {
-        const result2 = await runProcess({ executable: shellPath(), args: ["-c", command], marker: "" }, canonicalCwd, execOptions, null);
+        const result2 = await runProcess(unconfinedCommand(requireShell(shell), command), canonicalCwd, execOptions, null);
         return { exitCode: result2.exitCode };
       }
-      if (scope === "outside") {
-        const reason = "This command requests filesystem writes outside the active project workspace. It will not run until this one-call request is approved.";
+      if (scope === "outside" || platform === "win32") {
+        const resolved2 = requireShell(shell);
+        const reason = scope === "outside" ? "This command requests filesystem writes outside the active project workspace. It will not run until this one-call request is approved." : WINDOWS_UNSANDBOXED_REASON;
         let approved = false;
         try {
           approved = await options.requestWorkspaceWriteScope?.({ command, cwd: canonicalCwd, workspaceRoot: root, reason }) ?? false;
@@ -1722,12 +1887,11 @@ function createWorkspaceBashOperations(workspaceRoot, options = {}) {
           approved = false;
         }
         if (!approved) throw new Error(`${reason} Bash was not run.`);
-        execOptions.onData(Buffer.from("\n[Outside-workspace writes approved for this command; running once.]\n"));
-        const result2 = await runProcess({ executable: shellPath(), args: ["-c", command], marker: "" }, canonicalCwd, execOptions, null);
+        if (scope === "outside") execOptions.onData(Buffer.from("\n[Outside-workspace writes approved for this command; running once.]\n"));
+        const result2 = await runProcess(unconfinedCommand(resolved2, command), canonicalCwd, execOptions, null);
         return { exitCode: result2.exitCode };
       }
       assertNoExternalHardlinks(root);
-      const platform = options.platform ?? process.platform;
       const spec = workspaceSandboxCommand(platform, root, canonicalCwd, command);
       const result = await runProcess(spec, canonicalCwd, execOptions, spec.marker);
       return { exitCode: result.exitCode };
@@ -1736,12 +1900,17 @@ function createWorkspaceBashOperations(workspaceRoot, options = {}) {
 }
 
 // src/core/workspaceBashTool.ts
-function withWorkspaceWriteScope(tool) {
+function createWorkspaceShellTool(pi, cwd, operations, shell = hostShell(), platform = process.platform) {
+  const native = shell?.kind === "powershell" ? { ...pi.createPowerShellTool(cwd, { operations }), name: "bash" } : pi.createBashTool(cwd, { operations });
+  const note = platform === "win32" && shell ? ` On this machine commands run in ${shellLabel(shell)}. Windows has no workspace sandbox, so each command asks for approval unless Full Permission is on, and plan mode cannot run commands.` : "";
+  return withWorkspaceWriteScope(native, note);
+}
+function withWorkspaceWriteScope(tool, note = "") {
   const native = tool;
   const execute = native.execute.bind(tool);
   return {
     ...tool,
-    description: `${native.description} Workspace writes are the default. Set workspaceWriteScope to "outside" to request approval before broader writes. Commands run for ${DEFAULT_COMMAND_TIMEOUT_SECONDS} seconds unless timeout says otherwise; above ${COMMAND_TIMEOUT_CEILING_SECONDS} seconds a reason is required, and ${COMMAND_TIMEOUT_MAX_SECONDS} seconds is the maximum.`,
+    description: `${native.description}${note} Workspace writes are the default. Set workspaceWriteScope to "outside" to request approval before broader writes. Commands run for ${DEFAULT_COMMAND_TIMEOUT_SECONDS} seconds unless timeout says otherwise; above ${COMMAND_TIMEOUT_CEILING_SECONDS} seconds a reason is required, and ${COMMAND_TIMEOUT_MAX_SECONDS} seconds is the maximum.`,
     parameters: Type.Object({
       command: Type.String({ description: "Shell command to execute" }),
       timeout: Type.Optional(Type.Number({ description: `Timeout in seconds (default ${DEFAULT_COMMAND_TIMEOUT_SECONDS})` })),
@@ -1767,7 +1936,7 @@ function withWorkspaceWriteScope(tool) {
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { constants as fsConstants, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
+import { constants as fsConstants, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { dirname as dirname2, resolve as resolve2 } from "node:path";
 var writeAuthorization = new AsyncLocalStorage2();
@@ -1816,6 +1985,22 @@ try {
   throw error
 }
 `;
+function atomicWriteLaunch(platform, root, additionalRoots) {
+  if (platform === "win32") {
+    const env = {};
+    for (const name of ["SystemRoot", "windir", "TEMP", "TMP", "USERPROFILE"]) {
+      if (process.env[name]) env[name] = process.env[name];
+    }
+    return { executable: process.execPath, args: ["-e", atomicWriteScript], env };
+  }
+  const command = `exec ${shellQuote(process.execPath)} -e ${shellQuote(atomicWriteScript)}`;
+  const spec = workspaceSandboxCommand(platform, root, root, command, additionalRoots);
+  return {
+    executable: spec.executable,
+    args: spec.args,
+    env: { PATH: "/usr/bin:/bin", ...process.env.HOME ? { HOME: process.env.HOME } : {} }
+  };
+}
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -1824,7 +2009,7 @@ function nearestExistingDirectory(path) {
   while (true) {
     try {
       const canonical2 = realpathSync3(current);
-      if (!statSync3(canonical2).isDirectory()) throw new Error(`Write scope is not a directory: ${canonical2}`);
+      if (!statSync5(canonical2).isDirectory()) throw new Error(`Write scope is not a directory: ${canonical2}`);
       return canonical2;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -1853,17 +2038,12 @@ async function runAtomicWrite(authorization, path, content) {
     throw new Error("The write authorization no longer matches the active workspace target.");
   }
   const additionalRoots = outside ? [nearestExistingDirectory(canonicalPath)] : [];
-  const command = `exec ${shellQuote(process.execPath)} -e ${shellQuote(atomicWriteScript)}`;
-  const spec = workspaceSandboxCommand(process.platform, root, root, command, additionalRoots);
-  const env = {
-    PATH: "/usr/bin:/bin",
-    ...process.env.HOME ? { HOME: process.env.HOME } : {}
-  };
+  const launch = atomicWriteLaunch(process.platform, root, additionalRoots);
   await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn2(spec.executable, spec.args, {
+    const child = spawn2(launch.executable, launch.args, {
       cwd: root,
       detached: process.platform !== "win32",
-      env,
+      env: launch.env,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
@@ -2051,6 +2231,7 @@ async function piExtension_default(pi, planRun, getSession) {
   let context = null;
   let nativeSubagents = false;
   let subagentParent = false;
+  let stoppedChildren = null;
   let timer = null;
   let polling = false;
   let failure;
@@ -2132,13 +2313,13 @@ async function piExtension_default(pi, planRun, getSession) {
     },
     workspaceWriteScope: () => planRun?.active ? "read-only" : void 0
   });
-  pi.registerTool(withWorkspaceWriteScope(createBashTool(process.cwd(), { operations: workspaceBash })));
+  pi.registerTool(createWorkspaceShellTool({ createBashTool, createPowerShellTool }, process.cwd(), workspaceBash));
   pi.registerTool(withWorkspaceWriteAuthorization(createWriteTool(process.cwd(), { operations: workspaceWriteOperations }), writeAuthorizations));
   pi.registerTool(withWorkspaceWriteAuthorization(createEditTool(process.cwd(), { operations: workspaceEditOperations }), writeAuthorizations));
   compactionCheckpoint({ planInstructions: () => planRun?.active ? PLAN_INSTRUCTIONS : null })(pi);
   const slicePolicy = parseWorkSlice(void 0);
   const sliceState = createSliceState(slicePolicy);
-  if (slicePolicy.enabled) workSliceGuard({ policy: slicePolicy, state: sliceState })(pi);
+  if (slicePolicy.enabled) workSliceGuard({ policy: slicePolicy, state: sliceState, checkpointAvailable: () => !planRun?.active || planRun.allowedTools.has(CHECKPOINT_WRITE) })(pi);
   pi.on("context", (event) => {
     const messages = pruneToolImages(event.messages);
     return messages === event.messages ? void 0 : { messages };
@@ -2146,7 +2327,7 @@ async function piExtension_default(pi, planRun, getSession) {
   pi.on("session_start", async (_event, ctx) => {
     context = ctx;
     if (timer) clearInterval(timer);
-    await terminalCall("ready", { nativeSessionId: ctx.sessionManager.getSessionFile() });
+    await terminalCall("ready", { nativeSessionId: ctx.sessionManager.getSessionFile(), owners: subagentHistory(ctx.sessionManager.getBranch?.() ?? []).owners });
     timer = setInterval(() => {
       if (polling || !context) return;
       polling = true;
@@ -2170,13 +2351,16 @@ async function piExtension_default(pi, planRun, getSession) {
     usage = emptyUsage();
     reasoningTokens = void 0;
     costReported = false;
-    const begun = await terminalCall("begin", { text: event.messageType === "user" ? event.prompt : "" });
+    const begun = await terminalCall("begin", { text: event.messageType === "user" ? event.prompt : "", model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel?.() ?? null });
     workspaceRoot = typeof begun.workspaceRoot === "string" ? begun.workspaceRoot : null;
     if (!workspaceRoot) throw new Error("The active project workspace could not be resolved; the turn was not started.");
+    pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
+    stoppedChildren = null;
     if (nativeSubagents) {
-      pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
       const snapshot = await controlCall("terminal.subagents.register", { tools: pi.getActiveTools(), model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel(), plan: planRun?.active === true, history: subagentHistory(ctx.sessionManager.getBranch()) });
       if (planRun && Array.isArray(snapshot.connectors)) planRun.connectors = snapshot.connectors;
+      if (planRun && snapshot.subagentProfiles) planRun.subagentProfiles = snapshot.subagentProfiles;
+      stoppedChildren = snapshot.notice ?? null;
       subagentParent = true;
     }
     if (planRun && event.messageType === "user") {
@@ -2232,6 +2416,11 @@ async function piExtension_default(pi, planRun, getSession) {
     const instruction = refusal ? `The user's initial Bash command was not run. Reason: ${refusal}. Do not claim that it ran; explain the limitation and ask how to proceed.` : "The user\u2019s initial Bash command has already run. Read its native Bash result and explain what it shows. Do not run the same command again unless the user explicitly asks.";
     return { message: { customType: "xingular-initial-bash", content: instruction, display: false, details: {} } };
   });
+  pi.on("before_agent_start", async () => {
+    const notice = stoppedChildren;
+    stoppedChildren = null;
+    if (notice) return { message: { customType: SUBAGENT_RESULTS, content: notice.text, display: false, details: { [SUBAGENT_RECEIPT]: notice.receipt } } };
+  });
   const deliverChildren = async (event, ctx, settle) => {
     if (!nativeSubagents || settle && event.outcome !== "completed" || ctx.signal?.aborted) return;
     const result = await withParentCancellation(ctx.signal, () => controlCall("terminal.subagents.delivery", { history: subagentHistory([...ctx.sessionManager.getBranch(), ...event.entries]), settle }, 2147483647));
@@ -2391,17 +2580,17 @@ async function piExtension_default(pi, planRun, getSession) {
     }
   });
   let recorded = Promise.resolve();
-  const checklist = checklistTool({ emit: (_type, payload) => {
-    recorded = terminalCall("checklist", payload);
+  const todo = todoTool({ emit: (_type, payload) => {
+    recorded = terminalCall("todo", payload);
   } });
   pi.registerTool({
-    name: checklist.name,
-    label: checklist.label,
-    description: checklist.description,
-    parameters: Type2.Unsafe(checklist.parameters(Type2)),
+    name: todo.name,
+    label: todo.label,
+    description: todo.description,
+    parameters: Type2.Unsafe(todo.parameters(Type2)),
     async execute(_id, input) {
       recorded = Promise.resolve();
-      const result = await checklist.execute(input);
+      const result = await todo.execute(input);
       await recorded;
       return { content: [{ type: "text", text: typeof result === "string" ? result : result.text }], details: void 0 };
     }