flavor-code 1.4.2 → 1.4.3

package/dist/chunk-X6U6BO5D.js

@@ -0,0 +1,2130 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  message
+} from "./chunk-BDX777JR.js";
+import {
+  PermissionModeSchema
+} from "./chunk-ONRY3C2L.js";
+import {
+  external_exports
+} from "./chunk-EWD7FWTH.js";
+
+// src/session/store.ts
+import { constants } from "fs";
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat } from "fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+import { randomUUID } from "crypto";
+
+// src/agent/planner.ts
+var TaskNodeSchema = external_exports.object({
+  id: external_exports.string().trim().min(1),
+  description: external_exports.string().trim().min(1),
+  dependencies: external_exports.array(external_exports.string().trim().min(1)),
+  expectedOutputs: external_exports.array(external_exports.string().trim().min(1)),
+  verification: external_exports.array(external_exports.string().trim().min(1)),
+  files: external_exports.array(external_exports.string().trim().min(1)).describe(
+    "Workspace files this task owns for writing. Tasks whose files overlap are never run in parallel, so declare every file this task may create or modify."
+  ).optional()
+}).strict();
+var TaskGraphSchema = external_exports.object({
+  nodes: external_exports.array(TaskNodeSchema)
+}).strict().superRefine((graph, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, task] of graph.nodes.entries()) {
+    if (ids.has(task.id)) {
+      context.addIssue({ code: "custom", path: ["nodes", index, "id"], message: `Duplicate task id: ${task.id}` });
+    }
+    ids.add(task.id);
+  }
+  for (const [index, task] of graph.nodes.entries()) {
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const dependency of task.dependencies) {
+      if (!ids.has(dependency)) {
+        context.addIssue({ code: "custom", path: ["nodes", index, "dependencies"], message: `Unknown dependency: ${dependency}` });
+      }
+      if (dependencies.has(dependency)) {
+        context.addIssue({ code: "custom", path: ["nodes", index, "dependencies"], message: `Duplicate dependency: ${dependency}` });
+      }
+      dependencies.add(dependency);
+    }
+  }
+  if (ids.size === graph.nodes.length && hasCycle(graph.nodes)) {
+    context.addIssue({ code: "custom", path: ["nodes"], message: "Task graph contains a cycle" });
+  }
+});
+var TaskPlanner = class {
+  #hooks;
+  constructor(options) {
+    this.#hooks = options.hooks;
+  }
+  async plan(input, signal) {
+    let outcome = "failed";
+    let graph;
+    let primaryError;
+    let hasPrimaryError = false;
+    try {
+      const before = await this.#hooks.emit({
+        version: 1,
+        type: "BeforePlan",
+        payload: { graph: input }
+      }, signal);
+      if (before.decision === "deny") throw new Error(before.reason ?? "Planning denied by hook");
+      signal?.throwIfAborted();
+      graph = TaskGraphSchema.parse(before.updatedInput === void 0 ? input : updatedGraph(before.updatedInput));
+      outcome = "completed";
+    } catch (error) {
+      outcome = signal?.aborted ? "cancelled" : "failed";
+      primaryError = error;
+      hasPrimaryError = true;
+    }
+    try {
+      await this.#hooks.emit({
+        version: 1,
+        type: "AfterPlan",
+        payload: { outcome }
+      });
+    } catch (afterPlanError) {
+      if (!hasPrimaryError) throw afterPlanError;
+      attachAfterPlanError(primaryError, afterPlanError);
+    }
+    if (hasPrimaryError) throw primaryError;
+    return graph;
+  }
+};
+function attachAfterPlanError(primary, afterPlanError) {
+  try {
+    if (typeof primary !== "object" && typeof primary !== "function" || primary === null || !Object.isExtensible(primary)) return;
+    Object.defineProperty(primary, "afterPlanError", {
+      value: afterPlanError,
+      configurable: true
+    });
+    if (!("cause" in primary)) {
+      Object.defineProperty(primary, "cause", {
+        value: afterPlanError,
+        configurable: true
+      });
+    }
+  } catch {
+  }
+}
+function updatedGraph(input) {
+  if (typeof input !== "object" || input === null || !("graph" in input)) {
+    throw new Error("BeforePlan updatedInput must contain graph");
+  }
+  return input.graph;
+}
+function hasCycle(nodes) {
+  const indegree = new Map(nodes.map((task) => [task.id, task.dependencies.length]));
+  const dependents = /* @__PURE__ */ new Map();
+  for (const task of nodes) {
+    for (const dependency of task.dependencies) {
+      const list = dependents.get(dependency) ?? [];
+      list.push(task.id);
+      dependents.set(dependency, list);
+    }
+  }
+  const ready = nodes.filter((task) => indegree.get(task.id) === 0).map((task) => task.id);
+  let visited = 0;
+  for (let cursor = 0; cursor < ready.length; cursor += 1) {
+    const id = ready[cursor];
+    visited += 1;
+    for (const dependent of dependents.get(id) ?? []) {
+      const next = (indegree.get(dependent) ?? 0) - 1;
+      indegree.set(dependent, next);
+      if (next === 0) ready.push(dependent);
+    }
+  }
+  return visited !== nodes.length;
+}
+
+// src/models/types.ts
+function modelContentText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+}
+function modelContentTranscriptText(content) {
+  if (typeof content === "string") return content;
+  let image = 0;
+  return content.map((block) => block.type === "text" ? block.text : `[Image #${++image}]`).filter(Boolean).join("\n");
+}
+function cloneModelContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((block) => block.type === "text" ? { ...block } : { ...block, source: { ...block.source } });
+}
+function normalizeProviderError(error) {
+  const value = typeof error === "object" && error !== null ? error : { message: String(error) };
+  const status = typeof value.status === "number" ? value.status : void 0;
+  const providerCode = [value.code, value.type].filter((part) => typeof part === "string").join(" ").toLowerCase();
+  const message2 = typeof value.message === "string" ? value.message : "Unknown provider error";
+  const searchable = `${providerCode} ${message2}`.toLowerCase();
+  let code = "unknown";
+  if (value.name === "AbortError" || searchable.includes("abort") || searchable.includes("cancel")) {
+    code = "cancelled";
+  } else if (status === 401 || status === 403 || /auth|api.?key|unauthorized/.test(searchable)) {
+    code = "authentication";
+  } else if (status === 429 || /rate.?limit|overloaded/.test(searchable)) {
+    code = "rate_limit";
+  } else if (/context[_\s-]?(?:length|window|overflow)(?:[_\s-]?(?:exceeded|limit))?/.test(searchable) || /maximum context length|too many tokens|prompt.*(?:too )?long/.test(searchable)) {
+    code = "context_overflow";
+  } else if (status === 404 || /model.*not.?found|not.?found.*model/.test(searchable)) {
+    code = "model_not_found";
+  } else if (status === 400 || status === 422 || /invalid schema|schema.*(?:invalid|not (?:a )?valid)/.test(searchable)) {
+    code = "invalid_request";
+  } else if (status !== void 0 && status >= 500 && status <= 599) {
+    code = "network";
+  } else if (status === void 0 && /econn|enet|socket|network|fetch failed|connection|timeout/.test(searchable)) {
+    code = "network";
+  }
+  return { code, message: message2 };
+}
+
+// src/tools/task-output.ts
+var CommandRunSchema = external_exports.object({
+  command: external_exports.string().trim().min(1),
+  exitCode: external_exports.coerce.number().int().nullable(),
+  summary: external_exports.string().trim().min(1)
+});
+var VerificationItemSchema = external_exports.object({
+  name: external_exports.string().trim().min(1),
+  passed: external_exports.boolean(),
+  details: external_exports.string().trim().min(1)
+});
+var TaskOutputInput = external_exports.object({
+  summary: external_exports.string().trim().min(1),
+  filesChanged: external_exports.array(external_exports.string().trim().min(1)),
+  commandsRun: external_exports.array(CommandRunSchema),
+  verification: external_exports.array(VerificationItemSchema),
+  artifacts: external_exports.array(external_exports.string().trim().min(1)),
+  risks: external_exports.array(external_exports.string().trim().min(1)),
+  suggestedNextSteps: external_exports.array(external_exports.string().trim().min(1))
+});
+var TaskOutputResultSchema = TaskOutputInput.extend({
+  taskCompleted: external_exports.literal(true)
+}).strict();
+function createTaskOutputTool() {
+  return {
+    name: "TaskOutput",
+    description: "Produce a structured result that summarises task completion. Use this when a subagent has finished its work to report what was accomplished, what files were changed, which commands were run, verification results, and any risks or next steps. The main agent can also use this to produce a structured completion summary.",
+    inputSchema: TaskOutputInput,
+    paths: () => [],
+    summarize: (input) => input.summary,
+    execute: async (input) => TaskOutputResultSchema.parse({
+      taskCompleted: true,
+      summary: input.summary,
+      filesChanged: input.filesChanged,
+      commandsRun: input.commandsRun,
+      verification: input.verification,
+      artifacts: input.artifacts,
+      risks: input.risks,
+      suggestedNextSteps: input.suggestedNextSteps
+    })
+  };
+}
+
+// src/utils/async.ts
+function withTimeout(promise, ms) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      resolve2({ timedOut: true, value: void 0 });
+    }, ms);
+    timer.unref?.();
+    promise.then(
+      (value) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolve2({ timedOut: false, value });
+        }
+      },
+      (error) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+        }
+      }
+    );
+  });
+}
+function awaitWithSignal(promise, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/agent/subagents.ts
+var SubagentResultSchema = external_exports.object({
+  taskId: external_exports.string().min(1),
+  status: external_exports.enum(["completed", "failed", "blocked"]),
+  summary: external_exports.string(),
+  filesChanged: external_exports.array(external_exports.string()),
+  commandsRun: external_exports.array(external_exports.object({
+    command: external_exports.string(),
+    exitCode: external_exports.number().int().nullable(),
+    summary: external_exports.string()
+  }).strict()),
+  verification: external_exports.array(external_exports.object({
+    name: external_exports.string(),
+    passed: external_exports.boolean(),
+    details: external_exports.string()
+  }).strict()),
+  artifacts: external_exports.array(external_exports.string()),
+  risks: external_exports.array(external_exports.string()),
+  suggestedNextSteps: external_exports.array(external_exports.string())
+}).strict();
+function subagentResultFromTaskOutput(taskId, output) {
+  const parsed = TaskOutputResultSchema.safeParse(output);
+  if (!parsed.success) return void 0;
+  const { taskCompleted: _taskCompleted, ...result } = parsed.data;
+  return SubagentResultSchema.parse({ taskId, status: "completed", ...result });
+}
+function parseFinalSubagentMessage(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const candidate = messages[index];
+    if (candidate.role !== "assistant" || candidate.toolCalls !== void 0 && candidate.toolCalls.length > 0) continue;
+    const content = modelContentText(candidate.content);
+    try {
+      return JSON.parse(content.trim());
+    } catch {
+      return content;
+    }
+  }
+  return "";
+}
+var SubagentScheduler = class {
+  #options;
+  constructor(options) {
+    const maxSubagents = options.maxSubagents ?? 3;
+    if (!Number.isInteger(maxSubagents) || maxSubagents < 1 || maxSubagents > 16) {
+      throw new Error("maxSubagents must be an integer from 1 to 16");
+    }
+    this.#options = { ...options, maxSubagents };
+  }
+  async run(input, externalSignal) {
+    const graph = TaskGraphSchema.parse(input);
+    const controller = new AbortController();
+    const signal = externalSignal === void 0 ? controller.signal : AbortSignal.any([controller.signal, externalSignal]);
+    const states = new Map(graph.nodes.map((task) => [task.id, "pending"]));
+    const results = /* @__PURE__ */ new Map();
+    const running = /* @__PURE__ */ new Map();
+    const runningFiles = /* @__PURE__ */ new Map();
+    const started = /* @__PURE__ */ new Set();
+    try {
+      while (statesHaveWork(states)) {
+        signal.throwIfAborted();
+        await this.#blockDescendants(graph, states, results);
+        for (const task of graph.nodes) {
+          if (running.size >= this.#options.maxSubagents) break;
+          if (states.get(task.id) !== "pending" || !isReady(task, states)) continue;
+          if (conflictsWithRunning(task, runningFiles)) continue;
+          states.set(task.id, "running");
+          if (task.files !== void 0) runningFiles.set(task.id, task.files.map(normalizeOwnedFile));
+          const execution = this.#runTask(task, signal);
+          running.set(task.id, execution);
+          started.add(execution);
+        }
+        if (running.size === 0) {
+          await this.#blockDescendants(graph, states, results);
+          if (statesHaveWork(states)) throw new Error("Scheduler reached an invalid state with no runnable tasks");
+          break;
+        }
+        const completion = await Promise.race(running.values());
+        signal.throwIfAborted();
+        running.delete(completion.id);
+        runningFiles.delete(completion.id);
+        results.set(completion.id, completion.result);
+        states.set(completion.id, completion.result.status);
+        await this.#options.onResult?.(completion.result);
+      }
+      return orderedOutcome(graph, states, results);
+    } finally {
+      controller.abort(new Error("Subagent scheduler stopped"));
+      await Promise.allSettled(started);
+    }
+  }
+  async #blockDescendants(graph, states, results) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const task of graph.nodes) {
+        if (states.get(task.id) !== "pending") continue;
+        if (!task.dependencies.some((id) => ["failed", "blocked"].includes(states.get(id) ?? "pending"))) continue;
+        states.set(task.id, "blocked");
+        const result = syntheticResult(task, "blocked", "Blocked by a failed dependency");
+        results.set(task.id, result);
+        await this.#options.onResult?.(result);
+        changed = true;
+      }
+    }
+  }
+  async #runTask(task, signal) {
+    let failure;
+    let completion;
+    try {
+      const start = await this.#options.hooks.emit({
+        version: 1,
+        type: "SubagentStart",
+        payload: { taskId: task.id }
+      }, signal);
+      if (start.decision === "deny") throw new Error(start.reason ?? `Subagent ${task.id} denied by hook`);
+      for (const attempt of [1, 2]) {
+        signal.throwIfAborted();
+        const raw = await awaitWithSignal(this.#options.execute(task, { attempt, signal }), signal);
+        const parsed = SubagentResultSchema.safeParse(raw);
+        if (parsed.success && parsed.data.taskId === task.id) {
+          completion = { id: task.id, result: parsed.data };
+          break;
+        }
+        failure = parsed.success ? new Error(`Subagent result taskId ${parsed.data.taskId} does not match ${task.id}`) : parsed.error;
+      }
+      completion ??= {
+        id: task.id,
+        result: syntheticResult(task, "failed", `Invalid structured result after repair: ${message(failure)}`)
+      };
+    } catch (error) {
+      failure = error;
+      if (!signal.aborted) completion = { id: task.id, result: syntheticResult(task, "failed", message(error)) };
+    } finally {
+      try {
+        await this.#options.hooks.emit({
+          version: 1,
+          type: "SubagentStop",
+          payload: {
+            taskId: task.id,
+            status: signal.aborted ? "cancelled" : completion?.result.status ?? "failed",
+            ...failure === void 0 ? {} : { error: message(failure) }
+          }
+        });
+      } catch (stopError) {
+        if (!signal.aborted) {
+          failure = stopError;
+          completion = { id: task.id, result: syntheticResult(task, "failed", message(stopError)) };
+        }
+      }
+    }
+    if (signal.aborted) throw signal.reason;
+    return completion ?? { id: task.id, result: syntheticResult(task, "failed", message(failure)) };
+  }
+};
+function isReady(task, states) {
+  return task.dependencies.every((dependency) => states.get(dependency) === "completed");
+}
+function normalizeOwnedFile(value) {
+  return value.replace(/\\/g, "/");
+}
+function ownedFilesConflict(left, right) {
+  for (const one of left) {
+    for (const other of right) {
+      if (one === other) return true;
+      if (other.startsWith(`${one}/`) || one.startsWith(`${other}/`)) return true;
+    }
+  }
+  return false;
+}
+function conflictsWithRunning(task, runningFiles) {
+  if (task.files === void 0 || task.files.length === 0) return false;
+  const owned = task.files.map(normalizeOwnedFile);
+  for (const files of runningFiles.values()) {
+    if (ownedFilesConflict(owned, files)) return true;
+  }
+  return false;
+}
+function statesHaveWork(states) {
+  return [...states.values()].some((state) => state === "pending" || state === "running");
+}
+function syntheticResult(task, status, summary) {
+  return {
+    taskId: task.id,
+    status,
+    summary,
+    filesChanged: [],
+    commandsRun: [],
+    verification: [],
+    artifacts: [],
+    risks: [summary],
+    suggestedNextSteps: []
+  };
+}
+function orderedOutcome(graph, states, results) {
+  const orderedStates = {};
+  const orderedResults = {};
+  for (const task of graph.nodes) {
+    orderedStates[task.id] = states.get(task.id);
+    const result = results.get(task.id);
+    if (result !== void 0) orderedResults[task.id] = result;
+  }
+  return { states: orderedStates, results: orderedResults };
+}
+
+// src/agent/task-plan.ts
+var PlanTaskStatusSchema = external_exports.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "blocked",
+  "cancelled"
+]);
+var PlanTaskSchema = external_exports.object({
+  id: external_exports.string().trim().min(1),
+  subject: external_exports.string().trim().min(1),
+  activeForm: external_exports.string().trim().min(1),
+  status: PlanTaskStatusSchema,
+  dependencies: external_exports.array(external_exports.string().trim().min(1)),
+  result: external_exports.string().optional()
+}).strict();
+var TaskPlanSchema = external_exports.object({
+  tasks: external_exports.array(PlanTaskSchema)
+}).strict().superRefine((plan, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  let activeTasks = 0;
+  for (const [index, task] of plan.tasks.entries()) {
+    if (ids.has(task.id)) {
+      context.addIssue({ code: "custom", path: ["tasks", index, "id"], message: `Duplicate task id: ${task.id}` });
+    }
+    ids.add(task.id);
+    if (task.status === "in_progress") activeTasks += 1;
+  }
+  if (activeTasks > 1) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "Only one task may be in progress" });
+  }
+  for (const [index, task] of plan.tasks.entries()) {
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const dependency of task.dependencies) {
+      if (!ids.has(dependency)) {
+        context.addIssue({ code: "custom", path: ["tasks", index, "dependencies"], message: `Unknown dependency: ${dependency}` });
+      }
+      if (dependencies.has(dependency)) {
+        context.addIssue({ code: "custom", path: ["tasks", index, "dependencies"], message: `Duplicate dependency: ${dependency}` });
+      }
+      dependencies.add(dependency);
+    }
+    if (task.status === "completed" || task.status === "in_progress") {
+      const incomplete = task.dependencies.find((dependency) => plan.tasks.find((candidate) => candidate.id === dependency)?.status !== "completed");
+      if (incomplete !== void 0) {
+        context.addIssue({
+          code: "custom",
+          path: ["tasks", index, "status"],
+          message: `Task ${task.id} has an incomplete dependency: ${incomplete}`
+        });
+      }
+    }
+  }
+  if (ids.size === plan.tasks.length && hasCycle2(plan.tasks)) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "Task plan contains a cycle" });
+  }
+});
+var TaskUpdateInputSchema = external_exports.object({
+  taskId: external_exports.string().trim().min(1),
+  status: PlanTaskStatusSchema,
+  result: external_exports.string().optional()
+}).strict();
+function updatePlanTask(plan, input) {
+  const update = TaskUpdateInputSchema.parse(input);
+  const current = TaskPlanSchema.parse(plan);
+  const index = current.tasks.findIndex((task) => task.id === update.taskId);
+  if (index < 0) throw new Error(`Unknown task: ${update.taskId}`);
+  const previousStatus = current.tasks[index].status;
+  if (!isValidTransition(previousStatus, update.status)) {
+    throw new Error(`Invalid task transition for ${update.taskId}: ${previousStatus} -> ${update.status}`);
+  }
+  if (update.status === "completed" || update.status === "in_progress") {
+    const incomplete = current.tasks[index].dependencies.find((dependency) => current.tasks.find((task) => task.id === dependency)?.status !== "completed");
+    if (incomplete !== void 0) throw new Error(`Task ${update.taskId} has an incomplete dependency: ${incomplete}`);
+  }
+  return TaskPlanSchema.parse({
+    tasks: current.tasks.map((task, currentIndex) => currentIndex === index ? {
+      ...task,
+      status: update.status,
+      ...update.result === void 0 ? {} : { result: update.result }
+    } : { ...task })
+  });
+}
+function activateNextReadyTask(plan) {
+  const current = TaskPlanSchema.parse(plan);
+  if (current.tasks.some((task) => task.status === "in_progress")) return current;
+  const next = current.tasks.find((task) => task.status === "pending" && task.dependencies.every((dependency) => current.tasks.find((candidate) => candidate.id === dependency)?.status === "completed"));
+  if (next === void 0) return current;
+  return updatePlanTask(current, { taskId: next.id, status: "in_progress" });
+}
+function isValidTransition(from, to) {
+  if (from === to) return true;
+  if (from === "pending") return to === "in_progress" || to === "blocked" || to === "cancelled";
+  if (from === "in_progress") {
+    return to === "completed" || to === "failed" || to === "blocked" || to === "cancelled";
+  }
+  if (from === "blocked" || from === "failed") return to === "pending" || to === "in_progress" || to === "cancelled";
+  return false;
+}
+function normalizeAbandonedPlan(plan) {
+  const current = TaskPlanSchema.parse(plan);
+  return TaskPlanSchema.parse({
+    tasks: current.tasks.map((task) => task.status === "in_progress" ? {
+      ...task,
+      status: "cancelled",
+      result: "Execution was abandoned"
+    } : { ...task })
+  });
+}
+function hasCycle2(tasks) {
+  const indegree = new Map(tasks.map((task) => [task.id, task.dependencies.length]));
+  const dependents = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    for (const dependency of task.dependencies) {
+      const items = dependents.get(dependency) ?? [];
+      items.push(task.id);
+      dependents.set(dependency, items);
+    }
+  }
+  const ready = tasks.filter((task) => indegree.get(task.id) === 0).map((task) => task.id);
+  let visited = 0;
+  for (let index = 0; index < ready.length; index += 1) {
+    const id = ready[index];
+    visited += 1;
+    for (const dependent of dependents.get(id) ?? []) {
+      const next = (indegree.get(dependent) ?? 0) - 1;
+      indegree.set(dependent, next);
+      if (next === 0) ready.push(dependent);
+    }
+  }
+  return visited !== tasks.length;
+}
+
+// src/ui/char-width.ts
+function charWidth(codePoint) {
+  if (codePoint === 8203 || // ZERO WIDTH SPACE
+  codePoint === 8204 || // ZERO WIDTH NON-JOINER
+  codePoint === 8205 || // ZERO WIDTH JOINER
+  codePoint === 65279 || // BOM / ZERO WIDTH NO-BREAK SPACE
+  codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 1155 && codePoint <= 1161 || // Cyrillic combining marks
+  codePoint >= 1425 && codePoint <= 1469 || // Hebrew combining marks
+  codePoint >= 1552 && codePoint <= 1562 || // Arabic combining marks
+  codePoint >= 1611 && codePoint <= 1631 || // Arabic combining marks
+  codePoint >= 1648 && codePoint <= 1648 || // Arabic combining marks
+  codePoint >= 1750 && codePoint <= 1756 || // Arabic combining marks
+  codePoint >= 1759 && codePoint <= 1764 || // Arabic combining marks
+  codePoint >= 1767 && codePoint <= 1768 || // Arabic combining marks
+  codePoint >= 1770 && codePoint <= 1773 || // Arabic combining marks
+  codePoint >= 1809 && codePoint <= 1809 || // Syriac combining marks
+  codePoint >= 1840 && codePoint <= 1866 || // Syriac combining marks
+  codePoint >= 1958 && codePoint <= 1968 || // Thaana combining marks
+  codePoint >= 2304 && codePoint <= 2306 || // Devanagari combining marks
+  codePoint >= 2362 && codePoint <= 2362 || // Devanagari combining marks
+  codePoint >= 2364 && codePoint <= 2364 || // Devanagari combining marks
+  codePoint >= 2369 && codePoint <= 2376 || // Devanagari combining marks
+  codePoint >= 2381 && codePoint <= 2381 || // Devanagari combining marks
+  codePoint >= 2385 && codePoint <= 2391 || // Devanagari combining marks
+  codePoint >= 2402 && codePoint <= 2403 || // Devanagari combining marks
+  codePoint >= 2433 && codePoint <= 2433 || // Bengali combining marks
+  codePoint >= 2492 && codePoint <= 2492 || // Bengali combining marks
+  codePoint >= 2497 && codePoint <= 2500 || // Bengali combining marks
+  codePoint >= 2509 && codePoint <= 2509 || // Bengali combining marks
+  codePoint >= 2530 && codePoint <= 2531 || // Bengali combining marks
+  codePoint >= 2561 && codePoint <= 2562 || // Gurmukhi combining marks
+  codePoint >= 2620 && codePoint <= 2620 || // Gurmukhi combining marks
+  codePoint >= 2625 && codePoint <= 2626 || // Gurmukhi combining marks
+  codePoint >= 2631 && codePoint <= 2632 || // Gurmukhi combining marks
+  codePoint >= 2635 && codePoint <= 2637 || // Gurmukhi combining marks
+  codePoint >= 2672 && codePoint <= 2673 || // Gurmukhi combining marks
+  codePoint >= 2689 && codePoint <= 2690 || // Gujarati combining marks
+  codePoint >= 2748 && codePoint <= 2748 || // Gujarati combining marks
+  codePoint >= 2753 && codePoint <= 2757 || // Gujarati combining marks
+  codePoint >= 2759 && codePoint <= 2760 || // Gujarati combining marks
+  codePoint >= 2765 && codePoint <= 2765 || // Gujarati combining marks
+  codePoint >= 2786 && codePoint <= 2787 || // Gujarati combining marks
+  codePoint >= 2817 && codePoint <= 2817 || // Oriya combining marks
+  codePoint >= 2876 && codePoint <= 2876 || // Oriya combining marks
+  codePoint >= 2879 && codePoint <= 2879 || // Oriya combining marks
+  codePoint >= 2881 && codePoint <= 2883 || // Oriya combining marks
+  codePoint >= 2893 && codePoint <= 2893 || // Oriya combining marks
+  codePoint >= 2902 && codePoint <= 2902 || // Oriya combining marks
+  codePoint >= 2946 && codePoint <= 2946 || // Tamil combining marks
+  codePoint >= 3008 && codePoint <= 3008 || // Tamil combining marks
+  codePoint >= 3021 && codePoint <= 3021 || // Tamil combining marks
+  codePoint >= 3134 && codePoint <= 3136 || // Telugu combining marks
+  codePoint >= 3142 && codePoint <= 3144 || // Telugu combining marks
+  codePoint >= 3146 && codePoint <= 3149 || // Telugu combining marks
+  codePoint >= 3157 && codePoint <= 3158 || // Telugu combining marks
+  codePoint >= 3260 && codePoint <= 3260 || // Kannada combining marks
+  codePoint >= 3263 && codePoint <= 3263 || // Kannada combining marks
+  codePoint >= 3270 && codePoint <= 3270 || // Kannada combining marks
+  codePoint >= 3276 && codePoint <= 3277 || // Kannada combining marks
+  codePoint >= 3298 && codePoint <= 3299 || // Kannada combining marks
+  codePoint >= 3393 && codePoint <= 3395 || // Malayalam combining marks
+  codePoint >= 3405 && codePoint <= 3405 || // Malayalam combining marks
+  codePoint >= 3530 && codePoint <= 3530 || // Sinhala combining marks
+  codePoint >= 3538 && codePoint <= 3540 || // Sinhala combining marks
+  codePoint >= 3542 && codePoint <= 3542 || // Sinhala combining marks
+  codePoint >= 3633 && codePoint <= 3633 || // Thai combining marks
+  codePoint >= 3636 && codePoint <= 3642 || // Thai combining marks
+  codePoint >= 3655 && codePoint <= 3662 || // Thai combining marks
+  codePoint >= 3761 && codePoint <= 3761 || // Lao combining marks
+  codePoint >= 3764 && codePoint <= 3769 || // Lao combining marks
+  codePoint >= 3771 && codePoint <= 3772 || // Lao combining marks
+  codePoint >= 3784 && codePoint <= 3789 || // Lao combining marks
+  codePoint >= 3864 && codePoint <= 3865 || // Tibetan combining marks
+  codePoint >= 3893 && codePoint <= 3893 || // Tibetan combining marks
+  codePoint >= 3895 && codePoint <= 3895 || // Tibetan combining marks
+  codePoint >= 3897 && codePoint <= 3897 || // Tibetan combining marks
+  codePoint >= 3953 && codePoint <= 3966 || // Tibetan combining marks
+  codePoint >= 3968 && codePoint <= 3972 || // Tibetan combining marks
+  codePoint >= 3974 && codePoint <= 3975 || // Tibetan combining marks
+  codePoint >= 3984 && codePoint <= 3991 || // Tibetan combining marks
+  codePoint >= 3993 && codePoint <= 4028 || // Tibetan combining marks
+  codePoint >= 4038 && codePoint <= 4038 || // Tibetan combining marks
+  codePoint >= 4146 && codePoint <= 4151 || // Myanmar combining marks
+  codePoint >= 4153 && codePoint <= 4154 || // Myanmar combining marks
+  codePoint >= 4157 && codePoint <= 4158 || // Myanmar combining marks
+  codePoint >= 4184 && codePoint <= 4185 || // Myanmar combining marks
+  codePoint >= 4190 && codePoint <= 4192 || // Myanmar combining marks
+  codePoint >= 4209 && codePoint <= 4212 || // Myanmar combining marks
+  codePoint >= 4226 && codePoint <= 4226 || // Myanmar combining marks
+  codePoint >= 4229 && codePoint <= 4230 || // Myanmar combining marks
+  codePoint >= 4237 && codePoint <= 4237 || // Myanmar combining marks
+  codePoint >= 4957 && codePoint <= 4959 || // Ethiopic combining marks
+  codePoint >= 5906 && codePoint <= 5908 || // Tagalog combining marks
+  codePoint >= 5938 && codePoint <= 5940 || // Hanunoo combining marks
+  codePoint >= 5970 && codePoint <= 5971 || // Buhid combining marks
+  codePoint >= 6002 && codePoint <= 6003 || // Tagbanwa combining marks
+  codePoint >= 6068 && codePoint <= 6069 || // Khmer combining marks
+  codePoint >= 6071 && codePoint <= 6077 || // Khmer combining marks
+  codePoint >= 6086 && codePoint <= 6086 || // Khmer combining marks
+  codePoint >= 6089 && codePoint <= 6099 || // Khmer combining marks
+  codePoint >= 6109 && codePoint <= 6109 || // Khmer combining marks
+  codePoint >= 6155 && codePoint <= 6157 || // Mongolian combining marks
+  codePoint >= 6313 && codePoint <= 6313 || // Mongolian combining marks
+  codePoint >= 6432 && codePoint <= 6434 || // Limbu combining marks
+  codePoint >= 6439 && codePoint <= 6440 || // Limbu combining marks
+  codePoint >= 6450 && codePoint <= 6450 || // Limbu combining marks
+  codePoint >= 6457 && codePoint <= 6459 || // Limbu combining marks
+  codePoint >= 6679 && codePoint <= 6680 || // Buginese combining marks
+  codePoint >= 6912 && codePoint <= 6915 || // Balinese combining marks
+  codePoint >= 6964 && codePoint <= 6964 || // Balinese combining marks
+  codePoint >= 6966 && codePoint <= 6970 || // Balinese combining marks
+  codePoint >= 6972 && codePoint <= 6972 || // Balinese combining marks
+  codePoint >= 6978 && codePoint <= 6978 || // Balinese combining marks
+  codePoint >= 7019 && codePoint <= 7027 || // Balinese combining marks
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8432 || // Combining Diacritical Marks for Symbols
+  codePoint >= 11503 && codePoint <= 11505 || // Coptic combining marks
+  codePoint >= 11647 && codePoint <= 11647 || // Tifinagh combining marks
+  codePoint >= 11744 && codePoint <= 11775 || // Cyrillic Extended-A combining marks
+  codePoint >= 42607 && codePoint <= 42610 || // Cyrillic Extended-B combining marks
+  codePoint >= 42612 && codePoint <= 42621 || // Cyrillic Extended-B combining marks
+  codePoint >= 42654 && codePoint <= 42655 || // Cyrillic Extended-B combining marks
+  codePoint >= 42736 && codePoint <= 42737 || // Bamum combining marks
+  codePoint >= 43010 && codePoint <= 43010 || // Syloti Nagri combining marks
+  codePoint >= 43014 && codePoint <= 43014 || // Syloti Nagri combining marks
+  codePoint >= 43019 && codePoint <= 43019 || // Syloti Nagri combining marks
+  codePoint >= 43045 && codePoint <= 43046 || // Syloti Nagri combining marks
+  codePoint >= 43204 && codePoint <= 43204 || // Saurashtra combining marks
+  codePoint >= 43232 && codePoint <= 43249 || // Devanagari Extended combining marks
+  codePoint >= 43302 && codePoint <= 43309 || // Kayah Li combining marks
+  codePoint >= 43335 && codePoint <= 43345 || // Rejang combining marks
+  codePoint >= 43392 && codePoint <= 43394 || // Javanese combining marks
+  codePoint >= 43443 && codePoint <= 43443 || // Javanese combining marks
+  codePoint >= 43446 && codePoint <= 43449 || // Javanese combining marks
+  codePoint >= 43452 && codePoint <= 43452 || // Javanese combining marks
+  codePoint >= 43561 && codePoint <= 43566 || // Cham combining marks
+  codePoint >= 43569 && codePoint <= 43570 || // Cham combining marks
+  codePoint >= 43573 && codePoint <= 43574 || // Cham combining marks
+  codePoint >= 43587 && codePoint <= 43587 || // Cham combining marks
+  codePoint >= 43596 && codePoint <= 43596 || // Cham combining marks
+  codePoint >= 43696 && codePoint <= 43696 || // Tai Viet combining marks
+  codePoint >= 43698 && codePoint <= 43700 || // Tai Viet combining marks
+  codePoint >= 43703 && codePoint <= 43704 || // Tai Viet combining marks
+  codePoint >= 43710 && codePoint <= 43711 || // Tai Viet combining marks
+  codePoint >= 43713 && codePoint <= 43713 || // Tai Viet combining marks
+  codePoint >= 44005 && codePoint <= 44005 || // Meetei Mayek combining marks
+  codePoint >= 44008 && codePoint <= 44008 || // Meetei Mayek combining marks
+  codePoint >= 44013 && codePoint <= 44013 || // Meetei Mayek combining marks
+  codePoint >= 64286 && codePoint <= 64286 || // Hebrew combining marks
+  codePoint >= 65024 && codePoint <= 65039 || // Variation Selectors
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 917760 && codePoint <= 917999) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || // Hangul Jamo
+  codePoint >= 9001 && codePoint <= 9002 || // Left/Right-pointing angle bracket
+  codePoint >= 11904 && codePoint <= 12350 || // CJK Radicals Supplement, Kangxi Radicals, CJK Symbols
+  codePoint >= 12352 && codePoint <= 13247 || // Hiragana, Katakana, Bopomofo, Hangul Compatibility, Kanbun, CJK Strokes, Enclosed CJK
+  codePoint >= 13312 && codePoint <= 19903 || // CJK Unified Ideographs Extension A
+  codePoint >= 19968 && codePoint <= 42191 || // CJK Unified Ideographs, Yi Syllables, Yi Radicals
+  codePoint >= 43360 && codePoint <= 43388 || // Hangul Jamo Extended-A
+  codePoint >= 44032 && codePoint <= 55203 || // Hangul Syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK Compatibility Ideographs
+  codePoint >= 65040 && codePoint <= 65049 || // Vertical forms
+  codePoint >= 65072 && codePoint <= 65135 || // CJK Compatibility Forms, Small Form Variants
+  codePoint >= 65281 && codePoint <= 65376 || // Fullwidth Forms
+  codePoint >= 65504 && codePoint <= 65510 || // Fullwidth Signs
+  codePoint >= 110592 && codePoint <= 111359 || // Kana Supplement, Kana Extended-A, Small Kana Extension
+  codePoint >= 126980 && codePoint <= 126980 || // Mahjong tile
+  codePoint >= 127183 && codePoint <= 127183 || // Playing card
+  codePoint >= 127232 && codePoint <= 129535 || // Enclosed Alphanumeric Supplement, Emoticons, Transport, etc.
+  codePoint >= 129536 && codePoint <= 129647 || // Chess Symbols
+  codePoint >= 129648 && codePoint <= 129791 || // Symbols and Pictographs Extended-A
+  codePoint >= 131072 && codePoint <= 196605 || // CJK Unified Ideographs Extension B–G, CJK Compatibility Supplement
+  codePoint >= 196608 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+
+// src/ui/thinking-line.ts
+var THINKING_SCROLL_CELLS_PER_SEC = 16;
+var THINKING_EASE = 0.18;
+var THINKING_MAX_STEP_MS = 250;
+var THINKING_MAX_STORED_CHARS = 4e3;
+function normalizeThinkingText(text) {
+  return text.replace(/\s+/gu, " ").trim();
+}
+function thinkingDisplayWidth(text) {
+  let width = 0;
+  for (const character of text) width += charWidth(character.codePointAt(0) ?? 32);
+  return width;
+}
+function sliceThinkingByWidth(text, startCell, cellCount) {
+  let out = "";
+  let cell = 0;
+  for (const character of text) {
+    const w = charWidth(character.codePointAt(0) ?? 32);
+    if (cell + w > startCell && cell < startCell + cellCount) out += character;
+    cell += w;
+    if (cell >= startCell + cellCount) break;
+  }
+  return out;
+}
+function thinkingWindow(text, previousStart, options) {
+  const normalized = normalizeThinkingText(text);
+  const width = Math.max(1, Math.floor(options.width));
+  const total = thinkingDisplayWidth(normalized);
+  if (total <= width) return { text: normalized, start: 0 };
+  const maxStart = total - width;
+  const from = Math.min(Math.max(0, previousStart), maxStart);
+  const cellsPerSecond = options.cellsPerSecond ?? THINKING_SCROLL_CELLS_PER_SEC;
+  const ease = options.ease ?? THINKING_EASE;
+  const dt = Math.max(0, Math.min(options.dtMs, THINKING_MAX_STEP_MS));
+  const lag = maxStart - from;
+  const step = Math.max(cellsPerSecond * dt / 1e3, lag * ease);
+  const start = Math.min(maxStart, Math.floor(from + step));
+  return { text: sliceThinkingByWidth(normalized, start, width), start };
+}
+function appendThinkingText(previous, delta) {
+  const next = (previous ?? "") + delta;
+  return next.length > THINKING_MAX_STORED_CHARS ? next.slice(-THINKING_MAX_STORED_CHARS) : next;
+}
+
+// src/ui/transcript.ts
+var MAX_TRANSCRIPT_TURNS = 200;
+var MAX_TRANSCRIPT_CHARS = 2e6;
+var MAX_ACTIVE_TRANSCRIPT_BLOCKS = 160;
+var MAX_ACTIVE_ASSISTANT_CHARS = 64e3;
+var MAX_TRANSCRIPT_BLOCK_TEXT_CHARS = 16e3;
+var MAX_TRANSCRIPT_TOOL_VALUE_CHARS = 16e3;
+var MAX_TRANSCRIPT_PRESENTATION_CHARS = 32e3;
+function createTranscriptState() {
+  return { completed: [], nextId: 1 };
+}
+function transcriptReducer(state, action) {
+  if (action.type === "hydrate") return hydrateHistory(action.messages, action.compact);
+  if (action.type === "restore") return restoreTranscriptState(action.state);
+  if (action.type === "clear") return createTranscriptState();
+  if (action.type === "submit") {
+    const active = {
+      id: state.nextId,
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      prompt: action.prompt,
+      assistantText: "",
+      statusLines: [],
+      blocks: [],
+      ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot },
+      ...state.taskSnapshot === void 0 ? {} : { suppressedTaskIds: terminalTaskIds(state.taskSnapshot) }
+    };
+    return {
+      ...state,
+      active: state.taskSnapshot === void 0 ? active : applyTaskSnapshot(active, state.taskSnapshot, false),
+      nextId: state.nextId + 1
+    };
+  }
+  if (action.type === "finish") return finishActive(state);
+  if (action.type === "submit-error") {
+    if (state.active === void 0) return state;
+    return finishActive({
+      ...state,
+      active: addText(withoutModelActivity(state.active), `\u25C6 ${action.message}`, true)
+    });
+  }
+  const event = action.event;
+  if (event.type === "clear") return createTranscriptState();
+  if (event.type === "queued-prompt") {
+    return transcriptReducer(state.active === void 0 ? state : finishActive(state), {
+      type: "submit",
+      prompt: event.prompt
+    });
+  }
+  if (event.type === "queued-remote-prompt") {
+    return createPalTurn(state.active === void 0 ? state : finishActive(state), {
+      alias: event.senderAlias,
+      instanceId: event.senderId,
+      prompt: event.prompt,
+      ...event.context === void 0 ? {} : { context: event.context }
+    });
+  }
+  if (event.type === "tasks-cleared") {
+    const { taskSnapshot: _taskSnapshot, ...rest } = state;
+    return rest;
+  }
+  if (event.type === "tasks") {
+    const active = state.active === void 0 ? void 0 : applyTaskSnapshot(state.active, event.snapshot);
+    return {
+      ...state,
+      taskSnapshot: event.snapshot,
+      ...active === void 0 ? {} : { active }
+    };
+  }
+  if (event.type === "pal-task") return applyPalTaskEvent(state, event);
+  if (event.type === "cowork-event") return applyCoWorkEvent(state, event);
+  if (event.type === "exit" || state.active === void 0) return state;
+  if (event.type === "model-start") return upsertStatus({
+    ...state,
+    active: withoutModelActivity(state.active)
+  }, {
+    kind: "status",
+    id: `model:${event.id}`,
+    state: "running",
+    text: "Flavoring",
+    activity: "model",
+    startedAt: Date.now()
+  });
+  if (event.type === "model-end") return {
+    ...state,
+    active: withoutModelActivity(state.active, `model:${event.id}`)
+  };
+  if (event.type === "done") {
+    const usage = event.usage;
+    const cacheRead = usage.cacheReadTokens;
+    const hasCache = cacheRead !== void 0;
+    const percent = !hasCache || usage.inputTokens <= 0 ? 0 : Math.round(cacheRead / usage.inputTokens * 100);
+    const withUsage = upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
+      kind: "status",
+      id: `usage:${state.active.id}`,
+      state: "info",
+      text: hasCache ? `\xB7 ${usage.inputTokens} in \xB7 ${percent}% cached \xB7 ${usage.outputTokens} out` : `\xB7 ${usage.inputTokens} in \xB7 ${usage.outputTokens} out`,
+      ...hasCache ? { hint: `cache ${cacheRead}/${usage.inputTokens}` } : {}
+    });
+    return finishActive(withUsage);
+  }
+  if (event.type === "text") {
+    return { ...state, active: addStreamingText(state.active, event.text) };
+  }
+  if (event.type === "thinking") {
+    return { ...state, active: attachThinking(state.active, event.text) };
+  }
+  if (event.type === "tool-start") return upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
+    kind: "status",
+    id: `tool:${event.id}`,
+    state: "running",
+    text: `${event.name}${event.label ? ` ${event.label}` : ""}`,
+    ...event.hint === void 0 ? {} : { hint: event.hint },
+    ...event.presentation === void 0 ? {} : { presentation: event.presentation },
+    tool: { name: event.name, input: event.input }
+  });
+  if (event.type === "tool-end") {
+    const cancelled = !event.result.ok && event.result.error?.code === "cancelled";
+    const previous = state.active.blocks.find((block) => block.kind === "status" && block.id === `tool:${event.id}`);
+    const input = previous?.kind === "status" && previous.tool !== void 0 ? previous.tool.input : null;
+    const presentation = event.result.ok ? event.result.presentation ?? (previous?.kind === "status" ? previous.presentation : void 0) : void 0;
+    return upsertStatus(state, {
+      kind: "status",
+      id: `tool:${event.id}`,
+      state: event.result.ok ? "completed" : cancelled ? "cancelled" : "failed",
+      text: `${event.result.ok ? "\u2713" : "\xD7"} ${event.name}${event.label ? ` ${event.label}` : ""}`,
+      ...event.hint === void 0 ? {} : { hint: event.hint },
+      ...presentation === void 0 ? {} : { presentation },
+      tool: { name: event.name, input, result: event.result }
+    });
+  }
+  if (event.type === "deliverables") return upsertStatus(state, {
+    kind: "status",
+    id: `deliverables:${state.active.id}`,
+    state: "completed",
+    text: `Changed ${event.files.length} file${event.files.length === 1 ? "" : "s"}`,
+    details: event.files.map((file) => `${file.operation} ${file.path} (+${file.added} -${file.removed})`).join("\n"),
+    presentation: { kind: "changeset", files: event.files }
+  });
+  if (event.type === "notice") return upsertStatus(state, {
+    kind: "status",
+    id: `notice:${state.active.blocks.length}`,
+    state: "info",
+    text: `\xB7 ${event.message}`
+  });
+  if (event.type === "compact-progress") {
+    const progress = Math.max(0, Math.min(100, Math.floor(event.progress / 10) * 10));
+    return upsertStatus(state, {
+      kind: "status",
+      id: "compact:progress",
+      state: progress === 100 ? "completed" : "running",
+      text: "Compacting context",
+      progress
+    });
+  }
+  if (event.type === "error") {
+    const withoutActivity = withoutModelActivity(state.active);
+    const active = event.error.code === "cancelled" ? stripRetryBlocks(withoutActivity) : withoutActivity;
+    return { ...state, active: addText(active, `\u25C6 ${event.error.code}: ${event.error.message}`, true) };
+  }
+  if (event.type === "usage") return state;
+  if (event.type === "model-retry") return upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
+    kind: "status",
+    id: "model-retry",
+    state: "info",
+    tone: "retry",
+    text: `\u21BB Retrying model call \xB7 attempt ${event.attempt}/${event.maxAttempts} in ${event.delayMs / 1e3}s`
+  });
+  if (event.type === "structured-output-retry") return upsertStatus(state, {
+    kind: "status",
+    id: `structured-retry:${event.tool}`,
+    state: "info",
+    tone: "retry",
+    text: `\u21BB Repairing ${event.tool} arguments \xB7 attempt ${event.attempt}/${event.maxAttempts} in ${event.delayMs / 1e3}s`
+  });
+  if (event.type === "loop-progress") return upsertStatus(state, {
+    kind: "status",
+    id: `loop:${event.loopId}`,
+    state: event.state,
+    text: event.message
+  });
+  if (event.type === "compacted") return upsertStatus(state, {
+    kind: "status",
+    id: `compact:${state.active.blocks.length}`,
+    state: "info",
+    text: "\xB7 Context compacted."
+  });
+  if (event.type === "warning") return upsertStatus(state, {
+    kind: "status",
+    id: `warn:${state.active.blocks.length}`,
+    state: "info",
+    tone: "warning",
+    text: `\u26A0 ${event.message}`
+  });
+  if (event.type === "limit_reached") {
+    const suffix = event.extended ? " \u2014 auto-extended" : "";
+    return upsertStatus(state, {
+      kind: "status",
+      id: `limit:${state.active.blocks.length}`,
+      state: event.extended ? "info" : "failed",
+      text: `\u25C6 Iteration limit ${event.maxIterations} reached at round ${event.iteration}${suffix}`
+    });
+  }
+  return state;
+}
+var MAX_PEER_PRESENTATION_CHARS = 240;
+function boundedPeerText(value, fallback) {
+  const text = typeof value === "string" && value.length > 0 ? value : fallback;
+  return text.length <= MAX_PEER_PRESENTATION_CHARS ? text : `${text.slice(0, MAX_PEER_PRESENTATION_CHARS - 1)}\u2026`;
+}
+function palLabel(alias, instanceId) {
+  return `PAL \xB7 ${boundedPeerText(alias, "unknown")} (${instanceId.slice(0, 8)})`;
+}
+function createPalTurn(state, input) {
+  const active = {
+    id: state.nextId,
+    submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    prompt: boundedPeerText(input.prompt, "Peer collaboration update"),
+    assistantText: "",
+    statusLines: [],
+    blocks: [],
+    source: {
+      kind: "pal",
+      alias: boundedPeerText(input.alias, "unknown"),
+      instanceId: input.instanceId,
+      ...input.context === void 0 ? {} : { context: input.context }
+    },
+    ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
+  };
+  return { ...state, active, nextId: state.nextId + 1 };
+}
+function applyPalTaskEvent(state, event) {
+  if (state.active === void 0) {
+    return createPalTurn(state, {
+      alias: event.senderAlias,
+      instanceId: event.senderId,
+      prompt: event.goal
+    });
+  }
+  return upsertStatus(state, {
+    kind: "status",
+    id: `pal-task:${event.taskId}`,
+    state: "info",
+    text: `${palLabel(event.senderAlias, event.senderId)} \xB7 task received`,
+    details: boundedPeerText(event.goal, "Peer task")
+  });
+}
+function applyCoWorkEvent(initial, event) {
+  const snapshot = typeof event.snapshot === "object" && event.snapshot !== null ? event.snapshot : {};
+  const goal = boundedPeerText(snapshot.goal, "Co-work update");
+  const context = event.action === "START" ? "CO-WORK EXECUTION" : "CO-WORK PLANNING";
+  const wasIdle = initial.active === void 0;
+  let state = wasIdle ? createPalTurn(initial, { alias: event.senderAlias, instanceId: event.senderId, prompt: goal, context }) : initial;
+  if (event.action === "START" && state.active?.source?.kind === "pal") {
+    state = { ...state, active: { ...state.active, source: { ...state.active.source, context: "CO-WORK EXECUTION" } } };
+  }
+  const integration = typeof snapshot.integration === "object" && snapshot.integration !== null ? snapshot.integration : void 0;
+  const failedAssertion = Array.isArray(snapshot.completionAssertions) ? snapshot.completionAssertions.find((assertion) => typeof assertion === "object" && assertion !== null && assertion.passed === false) : void 0;
+  const passed = integration?.passed;
+  const details = event.action === "END" || event.action === "FAIL" ? boundedPeerText(integration?.evidence ?? failedAssertion?.detail, goal) : goal;
+  const stateByAction = event.action === "PROPOSE" || event.action === "START" ? "running" : event.action === "END" ? passed === false ? "failed" : "completed" : event.action === "FAIL" ? "failed" : event.action === "CANCEL" ? "cancelled" : "info";
+  const textByAction = event.action === "PROPOSE" ? "Co-work proposal received" : event.action === "PLAN" ? "Co-work plan updated" : event.action === "START" ? "Co-work execution started" : event.action === "END" ? passed === false ? "\xD7 Co-work ended \xB7 integration failed" : "\u2713 Co-work ended" : event.action === "FAIL" ? "\xD7 Co-work failed" : "\xD7 Co-work cancelled";
+  state = upsertStatus(state, {
+    kind: "status",
+    id: `cowork:${event.coWorkId}:${event.action}`,
+    state: stateByAction,
+    text: `${palLabel(event.senderAlias, event.senderId)} \xB7 ${textByAction}`,
+    details
+  });
+  if ((event.action === "END" || event.action === "FAIL" || event.action === "CANCEL") && (wasIdle || state.active?.source?.kind === "pal")) {
+    return finishActive(state);
+  }
+  return state;
+}
+function hydrateHistory(messages, compact) {
+  const completed = [];
+  if (compact !== void 0) completed.push(compactionTurn(compact));
+  let turn;
+  for (const message2 of messages) {
+    if (message2.role === "user") {
+      if (turn !== void 0) completed.push(turn);
+      turn = {
+        id: completed.length + 1,
+        prompt: modelContentTranscriptText(message2.content),
+        assistantText: "",
+        statusLines: [],
+        blocks: []
+      };
+    } else if (message2.role === "assistant" && turn !== void 0) {
+      const content = modelContentText(message2.content);
+      if (content.length > 0) turn = addText(turn, content);
+      for (const call of message2.toolCalls ?? []) {
+        turn = upsertTurnStatus(turn, {
+          kind: "status",
+          id: `tool:${call.id}`,
+          state: "running",
+          text: call.name,
+          tool: { name: call.name, input: call.input }
+        });
+      }
+    } else if (message2.role === "tool" && turn !== void 0) {
+      turn = applyLegacyToolResult(turn, message2);
+    }
+  }
+  if (turn !== void 0) completed.push(turn);
+  return { completed: boundedCompleted(completed), nextId: completed.length + 1 };
+}
+function transcriptFromLegacyConversation(messages, compact) {
+  return hydrateHistory(messages, compact);
+}
+function applyTaskSnapshot(turn, snapshot, includeTerminal = true) {
+  const taskBlocks = [];
+  const previous = new Map(turn.blocks.filter((block) => block.kind === "status").map((block) => [block.id, block]));
+  const now = Date.now();
+  const suppressed = new Set(turn.suppressedTaskIds ?? []);
+  for (const task of snapshot.plan?.tasks ?? []) {
+    const id = `task:${task.id}`;
+    const terminal = ["completed", "failed", "blocked", "cancelled"].includes(task.status);
+    if (!terminal) suppressed.delete(id);
+    if ((!includeTerminal || suppressed.has(id)) && terminal) continue;
+    const state = task.status === "in_progress" ? "running" : task.status === "completed" ? "completed" : task.status === "cancelled" ? "cancelled" : task.status === "failed" || task.status === "blocked" ? "failed" : "info";
+    const suffix = task.status === "completed" ? "done" : task.status.replace("_", " ");
+    const prior = previous.get(id);
+    const startedAt = state === "running" ? prior?.startedAt ?? now : prior?.startedAt;
+    const elapsedMs = state !== "running" && startedAt !== void 0 ? prior?.elapsedMs ?? Math.max(0, now - startedAt) : prior?.elapsedMs;
+    taskBlocks.push({
+      kind: "status",
+      id,
+      state,
+      text: `${state === "completed" ? "\u2713" : state === "failed" || state === "cancelled" ? "\xD7" : "\xB7"} ${task.subject} \xB7 ${suffix}`,
+      task: { subject: task.subject, activeForm: task.activeForm, role: "main" },
+      ...startedAt === void 0 ? {} : { startedAt },
+      ...elapsedMs === void 0 ? {} : { elapsedMs }
+    });
+  }
+  for (const node of snapshot.subagents.graph?.nodes ?? []) {
+    const status = snapshot.subagents.states[node.id] ?? "pending";
+    const id = `subagent:${node.id}`;
+    const terminal = ["completed", "failed", "blocked", "cancelled"].includes(status);
+    if (!terminal) suppressed.delete(id);
+    if ((!includeTerminal || suppressed.has(id)) && terminal) continue;
+    const state = status === "running" ? "running" : status === "completed" ? "completed" : status === "cancelled" ? "cancelled" : status === "failed" || status === "blocked" ? "failed" : "info";
+    const prior = previous.get(id);
+    const snapshotStartedAt = snapshot.subagents.startedAt?.[node.id];
+    const snapshotElapsedMs = snapshot.subagents.elapsedMs?.[node.id];
+    const startedAt = state === "running" ? snapshotStartedAt ?? prior?.startedAt ?? now : prior?.startedAt ?? snapshotStartedAt;
+    const elapsedMs = state !== "running" && startedAt !== void 0 ? prior?.elapsedMs ?? snapshotElapsedMs ?? Math.max(0, now - startedAt) : prior?.elapsedMs;
+    taskBlocks.push({
+      kind: "status",
+      id,
+      state,
+      text: `${state === "completed" ? "\u2713" : state === "failed" || state === "cancelled" ? "\xD7" : "\xB7"} subagent: ${node.description} \xB7 ${status}`,
+      task: { subject: node.description, activeForm: node.description, role: "subagent" },
+      ...startedAt === void 0 ? {} : { startedAt },
+      ...elapsedMs === void 0 ? {} : { elapsedMs }
+    });
+  }
+  const ids = new Set(taskBlocks.map((block) => block.id));
+  const blocks = turn.blocks.filter((block) => {
+    if (block.kind !== "status") return true;
+    if (!block.id.startsWith("task:") && !block.id.startsWith("subagent:")) return true;
+    return ids.has(block.id);
+  });
+  for (const block of taskBlocks) {
+    const index = blocks.findIndex((current) => current.kind === "status" && current.id === block.id);
+    if (index < 0) blocks.push(block);
+    else blocks[index] = block;
+  }
+  return {
+    ...withBlocks(turn, blocks),
+    taskSnapshot: snapshot,
+    suppressedTaskIds: [...suppressed]
+  };
+}
+function terminalTaskIds(snapshot) {
+  const ids = (snapshot.plan?.tasks ?? []).filter((task) => ["completed", "failed", "blocked", "cancelled"].includes(task.status)).map((task) => `task:${task.id}`);
+  for (const [id, status] of Object.entries(snapshot.subagents.states)) {
+    if (["completed", "failed", "blocked", "cancelled"].includes(status)) ids.push(`subagent:${id}`);
+  }
+  return ids;
+}
+function upsertStatus(state, block) {
+  if (state.active === void 0) return state;
+  const blocks = [...state.active.blocks];
+  const index = blocks.findIndex((item) => item.kind === "status" && item.id === block.id);
+  const bounded = boundedTranscriptBlock(block);
+  if (index < 0) blocks.push(bounded);
+  else blocks[index] = bounded;
+  return { ...state, active: withBlocks(state.active, blocks) };
+}
+function finishActive(state) {
+  if (state.active === void 0) return state;
+  const active = withoutModelActivity(state.active);
+  return {
+    completed: boundedCompleted([...state.completed, {
+      ...active,
+      completedAt: active.completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    }]),
+    nextId: state.nextId,
+    ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
+  };
+}
+function attachThinking(turn, text) {
+  const blocks = [...turn.blocks];
+  const index = blocks.findIndex((block2) => block2.kind === "status" && block2.activity === "model" && block2.state === "running");
+  if (index < 0) return turn;
+  const block = blocks[index];
+  if (block === void 0 || block.kind !== "status") return turn;
+  blocks[index] = {
+    ...block,
+    thinkingText: appendThinkingText(block.thinkingText, text)
+  };
+  return withBlocks(turn, blocks);
+}
+function withoutModelActivity(turn, id) {
+  const blocks = turn.blocks.filter((block) => block.kind !== "status" || block.activity !== "model" || id !== void 0 && block.id !== id);
+  if (blocks.length === turn.blocks.length) return turn;
+  return withBlocks(turn, blocks);
+}
+function restoreTranscriptState(state) {
+  const completed = state.completed.map(cloneTurn);
+  if (state.active !== void 0) completed.push(normalizeInterruptedTurn(cloneTurn(state.active)));
+  const nextId = Math.max(state.nextId, ...completed.map((turn) => turn.id + 1), 1);
+  return {
+    completed: boundedCompleted(completed),
+    nextId,
+    ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
+  };
+}
+function boundedCompleted(input) {
+  const recent = input.slice(-MAX_TRANSCRIPT_TURNS);
+  let chars = 0;
+  let start = recent.length;
+  for (let index = recent.length - 1; index >= 0; index -= 1) {
+    const turn = recent[index];
+    const size = JSON.stringify(turn).length;
+    if (start < recent.length && chars + size > MAX_TRANSCRIPT_CHARS) break;
+    chars += size;
+    start = index;
+  }
+  return recent.slice(start);
+}
+function compactionTurn(compact) {
+  const text = `Original execution steps before ${compact.compactedAt} are unavailable.`;
+  return {
+    id: 1,
+    kind: "compaction",
+    prompt: "Earlier execution history was compacted",
+    assistantText: "",
+    statusLines: [text],
+    blocks: [{
+      kind: "status",
+      id: `compact-boundary:${compact.compactedAt}`,
+      state: "info",
+      tone: "warning",
+      text,
+      details: compact.summary
+    }]
+  };
+}
+function applyLegacyToolResult(turn, message2) {
+  const id = message2.toolCallId;
+  const index = id === void 0 ? -1 : turn.blocks.findIndex((block2) => block2.kind === "status" && block2.id === `tool:${id}`);
+  if (index < 0) {
+    return upsertTurnStatus(turn, {
+      kind: "status",
+      id: `orphan-tool:${id ?? turn.blocks.length}`,
+      state: "info",
+      tone: "warning",
+      text: "Orphaned historical tool result",
+      details: modelContentText(message2.content)
+    });
+  }
+  const previous = turn.blocks[index];
+  if (previous.kind !== "status" || previous.tool === void 0) return turn;
+  const result = parseLegacyToolResult(modelContentText(message2.content));
+  const block = {
+    ...previous,
+    state: result.ok ? "completed" : "failed",
+    text: `${result.ok ? "\u2713" : "\xD7"} ${previous.tool.name}`,
+    tool: { ...previous.tool, result }
+  };
+  const blocks = [...turn.blocks];
+  blocks[index] = block;
+  return withBlocks(turn, blocks);
+}
+function parseLegacyToolResult(content) {
+  let value = content;
+  try {
+    value = JSON.parse(content);
+  } catch {
+  }
+  if (typeof value === "object" && value !== null && "error" in value) {
+    const candidate = value.error;
+    if (typeof candidate === "object" && candidate !== null) {
+      const error = candidate;
+      return { ok: false, error: {
+        code: typeof error.code === "string" ? error.code : "unknown",
+        message: typeof error.message === "string" ? error.message : content
+      } };
+    }
+  }
+  return { ok: true, output: value };
+}
+function normalizeInterruptedTurn(turn) {
+  const blocks = turn.blocks.flatMap((block) => {
+    if (block.kind !== "status") return [block];
+    if (block.activity === "model") return [];
+    if (block.state !== "running") return [block];
+    return [{ ...block, state: "cancelled", text: `\xD7 ${block.text.replace(/^[✓×·]\s*/, "")}` }];
+  });
+  return withBlocks(turn, blocks);
+}
+function cloneTurn(turn) {
+  return { ...turn, blocks: turn.blocks.map((block) => ({ ...block })), statusLines: [...turn.statusLines] };
+}
+function upsertTurnStatus(turn, block) {
+  const blocks = [...turn.blocks];
+  const index = blocks.findIndex((item) => item.kind === "status" && item.id === block.id);
+  const bounded = boundedTranscriptBlock(block);
+  if (index < 0) blocks.push(bounded);
+  else blocks[index] = bounded;
+  return withBlocks(turn, blocks);
+}
+function withBlocks(turn, blocks) {
+  const bounded = blocks.length <= MAX_ACTIVE_TRANSCRIPT_BLOCKS ? blocks : blocks.slice(-MAX_ACTIVE_TRANSCRIPT_BLOCKS);
+  return {
+    ...turn,
+    assistantText: tailText(turn.assistantText, MAX_ACTIVE_ASSISTANT_CHARS),
+    blocks: bounded,
+    statusLines: bounded.filter((block) => block.kind === "status").map((block) => block.text)
+  };
+}
+function appendLine(text, line) {
+  return text.length === 0 || text.endsWith("\n") ? text + line : `${text}
+${line}`;
+}
+function stripRetryBlocks(turn) {
+  const blocks = turn.blocks.filter((block) => {
+    if (block.kind !== "status") return true;
+    if (block.id === "model-retry") return false;
+    if (block.id.startsWith("structured-retry:")) return false;
+    return true;
+  });
+  return withBlocks(turn, blocks);
+}
+function addText(turn, text, onNewLine = false) {
+  const assistantText = tailText(
+    onNewLine ? appendLine(turn.assistantText, text) : turn.assistantText + text,
+    MAX_ACTIVE_ASSISTANT_CHARS
+  );
+  const blocks = [...turn.blocks];
+  const last = blocks[blocks.length - 1];
+  if (!onNewLine && last?.kind === "text") {
+    blocks[blocks.length - 1] = { kind: "text", text: tailText(last.text + text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) };
+  } else {
+    blocks.push({ kind: "text", text: tailText(text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) });
+  }
+  return withBlocks({ ...turn, assistantText }, blocks);
+}
+function addStreamingText(turn, text) {
+  const activity = turn.blocks.find((block) => block.kind === "status" && block.activity === "model" && block.state === "running");
+  if (activity === void 0) return addText(turn, text);
+  const withoutActivity = withBlocks(turn, turn.blocks.filter((block) => block !== activity));
+  const withText = addText(withoutActivity, text);
+  const { thinkingText: _thinkingText, ...writingActivity } = activity;
+  return withBlocks(withText, [...withText.blocks, {
+    ...writingActivity,
+    text: "Writing response"
+  }]);
+}
+function boundedTranscriptBlock(block) {
+  const presentation = block.presentation === void 0 ? void 0 : boundedTranscriptPresentation(block.presentation);
+  const tool = block.tool === void 0 ? void 0 : {
+    name: block.tool.name,
+    input: boundedTranscriptValue(block.tool.input),
+    ...block.tool.result === void 0 ? {} : {
+      result: {
+        ok: block.tool.result.ok,
+        ...block.tool.result.output === void 0 ? {} : { output: boundedTranscriptValue(block.tool.result.output) },
+        ...block.tool.result.content === void 0 ? {} : {
+          content: tailText(block.tool.result.content, MAX_TRANSCRIPT_TOOL_VALUE_CHARS)
+        },
+        ...block.tool.result.presentation === void 0 ? {} : {
+          presentation: boundedTranscriptPresentation(block.tool.result.presentation)
+        },
+        ...block.tool.result.additionalContext === void 0 ? {} : {
+          additionalContext: block.tool.result.additionalContext.slice(-20).map((item) => tailText(item, MAX_TRANSCRIPT_TOOL_VALUE_CHARS))
+        },
+        ...block.tool.result.error === void 0 ? {} : { error: {
+          code: block.tool.result.error.code,
+          message: tailText(block.tool.result.error.message, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS)
+        } }
+      }
+    }
+  };
+  return {
+    ...block,
+    text: tailText(block.text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS),
+    ...block.hint === void 0 ? {} : { hint: tailText(block.hint, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) },
+    ...block.details === void 0 ? {} : { details: tailText(block.details, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) },
+    ...presentation === void 0 ? {} : { presentation },
+    ...tool === void 0 ? {} : { tool }
+  };
+}
+function boundedTranscriptPresentation(presentation) {
+  return jsonSize(presentation) <= MAX_TRANSCRIPT_PRESENTATION_CHARS ? presentation : {
+    kind: "generic",
+    title: "Tool output",
+    summary: "Large presentation omitted from the live transcript; the model-facing result remains available in context."
+  };
+}
+function boundedTranscriptValue(value) {
+  const chars = jsonSize(value);
+  if (chars <= MAX_TRANSCRIPT_TOOL_VALUE_CHARS) return value;
+  const record = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  const summary = { truncated: true, originalChars: chars };
+  for (const key of ["path", "command", "id", "name", "exitCode", "bytes", "replacements"]) {
+    const item = record?.[key];
+    if (typeof item === "string") summary[key] = tailText(item, 1e3);
+    else if (typeof item === "number" || typeof item === "boolean" || item === null) summary[key] = item;
+  }
+  return summary;
+}
+function jsonSize(value) {
+  try {
+    return JSON.stringify(value)?.length ?? 0;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function tailText(text, limit) {
+  if (text.length <= limit) return text;
+  const marker = `\u2026 ${text.length - limit} earlier characters omitted \u2026
+`;
+  return marker.length >= limit ? text.slice(-limit) : marker + text.slice(-(limit - marker.length));
+}
+function transcriptCensus(state) {
+  const turns = [...state.completed, ...state.active === void 0 ? [] : [state.active]];
+  return {
+    turns: turns.length,
+    blocks: turns.reduce((total, turn) => total + turn.blocks.length, 0),
+    chars: jsonSize(state)
+  };
+}
+
+// src/session/store.ts
+var SESSION_VERSION = 4;
+var DEFAULT_MAX_SESSION_BYTES = 5 * 1024 * 1024;
+var SessionIdSchema = external_exports.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id");
+var IsoDateSchema = external_exports.string().datetime({ offset: true });
+var ToolCallSchema = external_exports.object({
+  id: external_exports.string().min(1).max(256),
+  name: external_exports.string().min(1).max(256),
+  input: external_exports.unknown()
+}).strict();
+var TextContentBlockSchema = external_exports.object({
+  type: external_exports.literal("text"),
+  text: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES)
+}).strict();
+var ImageContentBlockSchema = external_exports.object({
+  type: external_exports.literal("image"),
+  source: external_exports.object({ type: external_exports.literal("file"), path: external_exports.string().min(1).max(32768) }).strict(),
+  mediaType: external_exports.enum(["image/png", "image/jpeg", "image/webp"]),
+  sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  bytes: external_exports.number().int().positive().max(20 * 1024 * 1024),
+  name: external_exports.string().min(1).max(255).optional()
+}).strict();
+var UserContentSchema = external_exports.union([
+  external_exports.string().max(DEFAULT_MAX_SESSION_BYTES),
+  external_exports.array(external_exports.discriminatedUnion("type", [TextContentBlockSchema, ImageContentBlockSchema])).min(1).max(100)
+]);
+var MessageMetadataShape = {
+  toolCallId: external_exports.string().min(1).max(256).optional(),
+  toolCalls: external_exports.array(ToolCallSchema).max(1e3).optional()
+};
+var MessageSchema = external_exports.discriminatedUnion("role", [
+  external_exports.object({ role: external_exports.literal("user"), content: UserContentSchema, ...MessageMetadataShape }).strict(),
+  external_exports.object({ role: external_exports.literal("system"), content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
+  external_exports.object({ role: external_exports.literal("assistant"), content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
+  external_exports.object({ role: external_exports.literal("tool"), content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict()
+]);
+var LegacySummarySchema = external_exports.object({ role: external_exports.literal("system"), content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES) }).strict();
+var CompactBoundarySchema = external_exports.object({
+  summary: external_exports.string().min(1).max(DEFAULT_MAX_SESSION_BYTES),
+  compactedAt: IsoDateSchema
+}).strict();
+var StateSchema = external_exports.enum(["pending", "running", "completed", "failed", "blocked", "cancelled"]);
+var MemoryLifecycleSchema = external_exports.object({
+  status: external_exports.enum(["active", "completed", "abandoned"]),
+  taskId: external_exports.string().regex(/^memory-[A-Za-z0-9._-]{1,120}$/).optional(),
+  messageStart: external_exports.number().int().min(0).max(5e4).optional(),
+  finalizedAt: IsoDateSchema.optional(),
+  transcriptHash: external_exports.string().regex(/^[a-f0-9]{64}$/).optional()
+}).strict();
+var SessionBaseSchema = external_exports.object({
+  sessionId: SessionIdSchema,
+  createdAt: IsoDateSchema,
+  updatedAt: IsoDateSchema,
+  workspace: external_exports.object({ path: external_exports.string().min(1).max(32768) }).strict(),
+  tasks: external_exports.object({
+    plan: TaskPlanSchema.optional(),
+    graph: TaskGraphSchema.optional(),
+    states: external_exports.record(external_exports.string(), StateSchema),
+    results: external_exports.record(external_exports.string(), SubagentResultSchema)
+  }).strict(),
+  models: external_exports.object({ main: external_exports.string().min(1).max(1024), subagent: external_exports.string().min(1).max(1024) }).strict(),
+  permissionMode: PermissionModeSchema,
+  memory: MemoryLifecycleSchema.optional()
+}).strict();
+var SessionDocumentV1Schema = SessionBaseSchema.extend({
+  version: external_exports.literal(1),
+  conversation: external_exports.object({
+    summary: LegacySummarySchema.optional(),
+    messages: external_exports.array(MessageSchema).max(5e4)
+  }).strict()
+}).strict();
+var ConversationSchema = external_exports.object({
+  compact: CompactBoundarySchema.optional(),
+  messages: external_exports.array(MessageSchema).max(5e4)
+}).strict();
+var SessionDocumentV2Schema = SessionBaseSchema.extend({
+  version: external_exports.literal(2),
+  conversation: ConversationSchema
+}).strict();
+var TranscriptStateSchema = external_exports.custom(isTranscriptState, "Invalid transcript state");
+var TimelineSchema = external_exports.object({
+  version: external_exports.literal(1),
+  state: TranscriptStateSchema
+}).strict();
+var ContextEpochSchema = external_exports.object({
+  version: external_exports.literal(1),
+  id: external_exports.string().uuid(),
+  startedAt: IsoDateSchema,
+  stableMessages: external_exports.array(external_exports.object({
+    role: external_exports.literal("system"),
+    content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES),
+    cacheBreakpoint: external_exports.boolean().optional()
+  }).strict()).max(1e3),
+  sources: external_exports.record(external_exports.string().min(1).max(128), external_exports.string().max(DEFAULT_MAX_SESSION_BYTES)),
+  pinnedSources: external_exports.record(external_exports.string().min(1).max(128), external_exports.string().max(DEFAULT_MAX_SESSION_BYTES)).optional(),
+  stableSourceHash: external_exports.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var ContextVisibilityRecordSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  role: external_exports.literal("system"),
+  content: external_exports.string().max(DEFAULT_MAX_SESSION_BYTES),
+  admittedAt: IsoDateSchema,
+  scope: external_exports.literal("run")
+}).strict();
+var SessionDocumentV3Schema = SessionBaseSchema.extend({
+  version: external_exports.literal(3),
+  conversation: ConversationSchema,
+  timeline: TimelineSchema
+}).strict();
+var SessionDocumentSchema = SessionBaseSchema.extend({
+  version: external_exports.literal(SESSION_VERSION),
+  conversation: external_exports.object({
+    compact: CompactBoundarySchema.optional(),
+    epoch: ContextEpochSchema.optional(),
+    visibilityLog: external_exports.array(ContextVisibilityRecordSchema).max(1e4).optional(),
+    messages: external_exports.array(MessageSchema).max(5e4)
+  }).strict(),
+  timeline: TimelineSchema
+}).strict();
+var INVALID_SESSION_LOCK_STALE_MS = 3e4;
+var SessionStore = class {
+  #workspace;
+  #sessions;
+  #maxBytes;
+  #maxSessions;
+  constructor(options) {
+    this.#workspace = resolve(options.workspace);
+    this.#sessions = join(this.#workspace, ".flavor", "sessions");
+    this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_SESSION_BYTES;
+    if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 256) throw new Error("maxBytes must be an integer of at least 256");
+    this.#maxSessions = options.maxSessions ?? 50;
+    if (!Number.isSafeInteger(this.#maxSessions) || this.#maxSessions < 1) throw new Error("maxSessions must be an integer of at least 1");
+  }
+  async save(input) {
+    const document = SessionDocumentSchema.parse(sanitize(input));
+    await this.#assertWorkspace(document.workspace.path);
+    await this.#prepareDirectory();
+    const target = this.#path(document.sessionId);
+    const { conversation: { messages, compact, epoch, visibilityLog }, timeline, ...meta } = document;
+    const metaLine = JSON.stringify({
+      __meta: true,
+      ...meta,
+      ...compact === void 0 ? {} : { compact },
+      ...epoch === void 0 ? {} : { epoch },
+      ...visibilityLog === void 0 ? {} : { visibilityLog },
+      timeline: {
+        version: timeline.version,
+        nextId: timeline.state.nextId,
+        ...timeline.state.taskSnapshot === void 0 ? {} : { taskSnapshot: timeline.state.taskSnapshot }
+      }
+    });
+    const timelineLines = [
+      ...timeline.state.completed.map((turn) => JSON.stringify({ __timeline: true, turn })),
+      ...timeline.state.active === void 0 ? [] : [JSON.stringify({ __timeline: true, active: timeline.state.active })]
+    ];
+    const lines = [metaLine, ...messages.map((message2) => JSON.stringify(message2)), ...timelineLines];
+    const body = `${lines.join("\n")}
+`;
+    if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Session exceeds maximum size of ${this.#maxBytes} bytes`);
+    const temporary = join(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID()}.tmp`);
+    let handle;
+    try {
+      handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+      await handle.writeFile(body, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      await rename(temporary, target);
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await rm(temporary, { force: true }).catch(() => void 0);
+    }
+    await this.#prune().catch(() => void 0);
+  }
+  /** Hold this lease for the full lifetime of a writable session runtime. */
+  async acquireLease(sessionId) {
+    SessionIdSchema.parse(sessionId);
+    await this.#prepareDirectory();
+    const path = join(this.#sessions, `.${sessionId}.lock`);
+    const token = JSON.stringify({ pid: process.pid, nonce: randomUUID(), createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      let handle;
+      let created = false;
+      try {
+        handle = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+        created = true;
+        await handle.writeFile(token, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = void 0;
+        let released = false;
+        return {
+          sessionId,
+          release: async () => {
+            if (released) return;
+            try {
+              if (await readFile(path, "utf8") === token) await rm(path, { force: true });
+            } catch (error) {
+              if (!isCode(error, "ENOENT")) throw error;
+            }
+            released = true;
+          }
+        };
+      } catch (error) {
+        await handle?.close().catch(() => void 0);
+        if (created) await rm(path, { force: true }).catch(() => void 0);
+        if (!isCode(error, "EEXIST")) throw error;
+        const owner = await reclaimStaleSessionLock(path);
+        if (owner !== void 0) {
+          throw new Error(`Session "${sessionId}" is already active in process ${owner}. Close that session before resuming it here.`);
+        }
+      }
+    }
+    throw new Error(`Session "${sessionId}" could not acquire its writer lease because the lock kept changing`);
+  }
+  async load(sessionId) {
+    if (sessionId === void 0) {
+      const [latest] = await this.list();
+      if (latest === void 0) throw new Error("No saved sessions exist in this workspace");
+      sessionId = latest.sessionId;
+    }
+    SessionIdSchema.parse(sessionId);
+    await this.#assertSafeExistingDirectory();
+    const path = this.#path(sessionId);
+    let raw;
+    try {
+      raw = await boundedRead(path, this.#maxBytes);
+    } catch (error) {
+      if (isCode(error, "ENOENT")) throw new Error(`Session "${sessionId}" was not found in this workspace`);
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = this.#parseSession(raw);
+    } catch (error) {
+      const quarantine = await this.#quarantine(path);
+      throw new Error(`Session "${sessionId}" is corrupt or incompatible and was quarantined as ${basename(quarantine)}: ${message(error)}`);
+    }
+    await this.#assertWorkspace(parsed.workspace.path);
+    const storedVersion = storedSessionVersion(raw);
+    if (storedVersion < SESSION_VERSION) await this.#backupLegacy(path, raw, storedVersion);
+    return normalizeAbandonedTasks(parsed);
+  }
+  #parseSession(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) throw new Error("Empty session file");
+    const firstLine = trimmed.split("\n", 1)[0] ?? "";
+    let candidate;
+    const first = JSON.parse(firstLine);
+    if (first.__meta === true) {
+      const meta = { ...first };
+      const records = trimmed.split("\n").slice(1).filter((line) => line.length > 0).map((line) => JSON.parse(line));
+      const messages = records.filter((record) => !isTimelineRecord(record));
+      const timelineRecords = records.filter(isTimelineRecord);
+      const summary = meta.summary;
+      const compact = meta.compact;
+      const epoch = meta.epoch;
+      const visibilityLog = meta.visibilityLog;
+      const timeline = meta.timeline;
+      delete meta.__meta;
+      delete meta.summary;
+      delete meta.compact;
+      delete meta.epoch;
+      delete meta.visibilityLog;
+      delete meta.timeline;
+      candidate = {
+        ...meta,
+        conversation: {
+          ...meta.version === 1 && summary !== void 0 ? { summary } : {},
+          ...(meta.version === 2 || meta.version === 3 || meta.version === SESSION_VERSION) && compact !== void 0 ? { compact } : {},
+          ...meta.version === SESSION_VERSION && epoch !== void 0 ? { epoch } : {},
+          ...meta.version === SESSION_VERSION && visibilityLog !== void 0 ? { visibilityLog } : {},
+          messages
+        },
+        ...meta.version === 3 || meta.version === SESSION_VERSION ? {
+          timeline: timelineFromRecords(timeline, timelineRecords)
+        } : {}
+      };
+    } else {
+      candidate = JSON.parse(trimmed);
+    }
+    return parseAndMigrateSession(candidate);
+  }
+  async list() {
+    try {
+      await this.#assertSafeExistingDirectory();
+    } catch (error) {
+      if (isCode(error, "ENOENT")) return [];
+      throw error;
+    }
+    const names = (await readdir(this.#sessions)).filter((name) => name.endsWith(".jsonl") && !name.endsWith(".events.jsonl")).sort();
+    const entries = [];
+    for (const name of names) {
+      const id = name.slice(0, -6);
+      if (!SessionIdSchema.safeParse(id).success) continue;
+      try {
+        const document = await this.load(id);
+        entries.push({ sessionId: document.sessionId, createdAt: document.createdAt, updatedAt: document.updatedAt, mainModel: document.models.main });
+      } catch (error) {
+        if (!/corrupt|quarantined/i.test(message(error))) throw error;
+      }
+    }
+    return entries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.sessionId.localeCompare(b.sessionId));
+  }
+  async delete(sessionId) {
+    SessionIdSchema.parse(sessionId);
+    try {
+      await this.#assertSafeExistingDirectory();
+    } catch (error) {
+      if (isCode(error, "ENOENT")) return;
+      throw error;
+    }
+    const owner = await reclaimStaleSessionLock(join(this.#sessions, `.${sessionId}.lock`));
+    if (owner !== void 0) throw new Error(`Session "${sessionId}" is active in process ${owner} and cannot be deleted`);
+    const path = this.#path(sessionId);
+    try {
+      const metadata = await lstat(path);
+      if (!metadata.isFile()) throw new Error("Session path is not a regular file");
+      await rm(path);
+      await rm(join(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+    }
+  }
+  #path(sessionId) {
+    SessionIdSchema.parse(sessionId);
+    const path = resolve(this.#sessions, `${sessionId}.jsonl`);
+    if (!isWithin(this.#sessions, path)) throw new Error("Invalid session id");
+    return path;
+  }
+  async #prune() {
+    const entries = await this.list();
+    if (entries.length <= this.#maxSessions) return;
+    let retained = 0;
+    for (const entry of entries) {
+      const owner = await reclaimStaleSessionLock(join(this.#sessions, `.${entry.sessionId}.lock`));
+      if (owner !== void 0) continue;
+      if (retained < this.#maxSessions) {
+        retained += 1;
+        continue;
+      }
+      await rm(this.#path(entry.sessionId), { force: true }).catch(() => void 0);
+      await rm(join(this.#sessions, `${entry.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+    }
+  }
+  async #assertWorkspace(stored) {
+    const expected = await canonical(this.#workspace);
+    const actual = await canonical(stored);
+    if (process.platform === "win32" ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
+      throw new Error(`Session belongs to a different workspace: ${stored}. Resume it from that workspace.`);
+    }
+  }
+  async #prepareDirectory() {
+    await assertNoSymlink(this.#workspace, dirname(this.#sessions));
+    await mkdir(this.#sessions, { recursive: true, mode: 448 });
+    await this.#assertSafeExistingDirectory();
+  }
+  async #assertSafeExistingDirectory() {
+    await assertNoSymlink(this.#workspace, this.#sessions);
+    const canonicalRoot = await realpath(this.#workspace);
+    const canonicalSessions = await realpath(this.#sessions);
+    if (!isWithin(canonicalRoot, canonicalSessions)) throw new Error("Session directory escapes the workspace");
+  }
+  async #quarantine(path) {
+    const target = `${path}.corrupt-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    await rename(path, target);
+    return target;
+  }
+  async #backupLegacy(path, raw, version) {
+    const target = `${path}.v${version}.bak`;
+    let handle;
+    try {
+      handle = await open(target, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+      await handle.writeFile(raw, "utf8");
+      await handle.sync();
+    } catch (error) {
+      if (!isCode(error, "EEXIST")) throw error;
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+  }
+};
+function storedSessionVersion(raw) {
+  const trimmed = raw.trim();
+  const first = JSON.parse(trimmed.split("\n", 1)[0] ?? "{}");
+  const candidate = first.__meta === true ? first.version : JSON.parse(trimmed).version;
+  return typeof candidate === "number" && Number.isInteger(candidate) ? candidate : 0;
+}
+async function reclaimStaleSessionLock(path) {
+  try {
+    const token = await readFile(path, "utf8");
+    const metadata = await stat(path);
+    const owner = parseSessionLockOwner(token);
+    if (owner !== void 0 && isProcessAlive(owner)) return owner;
+    if (owner === void 0 && Date.now() - metadata.mtimeMs <= INVALID_SESSION_LOCK_STALE_MS) {
+      throw new Error(`Session writer lock ${path} is incomplete or invalid; retry after the owning process exits`);
+    }
+    if (await readFile(path, "utf8") !== token) return void 0;
+    const stale = `${path}.stale-${process.pid}-${randomUUID()}`;
+    try {
+      await rename(path, stale);
+      await rm(stale, { force: true });
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+    }
+    return void 0;
+  } catch (error) {
+    if (isCode(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
+function parseSessionLockOwner(token) {
+  try {
+    const value = JSON.parse(token);
+    if (typeof value !== "object" || value === null || !("pid" in value)) return void 0;
+    const pid = value.pid;
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isCode(error, "EPERM");
+  }
+}
+async function boundedRead(path, maxBytes) {
+  const metadata = await stat(path);
+  if (!metadata.isFile()) throw new Error("Session path is not a regular file");
+  if (metadata.size > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
+  const value = await readFile(path);
+  if (value.byteLength > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
+  return value.toString("utf8");
+}
+function normalizeAbandonedTasks(document) {
+  const plan = document.tasks.plan === void 0 ? void 0 : normalizeAbandonedPlan(document.tasks.plan);
+  const states = { ...document.tasks.states };
+  const results = { ...document.tasks.results };
+  const nodes = new Map(document.tasks.graph?.nodes.map((node) => [node.id, node]) ?? []);
+  for (const [id, state] of Object.entries(states)) {
+    if (state !== "running") continue;
+    const node = nodes.get(id);
+    const failedDependency = node?.dependencies.some((dependency) => ["failed", "blocked"].includes(states[dependency] ?? "pending")) ?? false;
+    states[id] = failedDependency ? "failed" : "pending";
+    if (failedDependency && results[id] === void 0) results[id] = {
+      taskId: id,
+      status: "failed",
+      summary: "Recovered as failed because a dependency did not complete",
+      filesChanged: [],
+      commandsRun: [],
+      verification: [],
+      artifacts: [],
+      risks: ["Execution was abandoned"],
+      suggestedNextSteps: []
+    };
+  }
+  const restoredTimeline = restoreTranscriptState(document.timeline.state);
+  const priorSnapshot = restoredTimeline.taskSnapshot;
+  const { taskSnapshot: _discardedTaskSnapshot, ...timelineWithoutTaskSnapshot } = restoredTimeline;
+  const hasTaskSnapshot = plan !== void 0 || document.tasks.graph !== void 0 || Object.keys(states).length > 0;
+  const timelineState = {
+    ...timelineWithoutTaskSnapshot,
+    ...hasTaskSnapshot ? {
+      taskSnapshot: {
+        ...plan === void 0 ? {} : { plan },
+        subagents: {
+          ...document.tasks.graph === void 0 ? {} : { graph: document.tasks.graph },
+          states: { ...states },
+          ...priorSnapshot?.subagents.elapsedMs === void 0 ? {} : { elapsedMs: priorSnapshot.subagents.elapsedMs }
+        }
+      }
+    } : {}
+  };
+  return {
+    ...document,
+    timeline: { ...document.timeline, state: timelineState },
+    tasks: {
+      ...document.tasks,
+      ...plan === void 0 ? {} : { plan },
+      states,
+      results
+    }
+  };
+}
+function parseAndMigrateSession(input) {
+  if (typeof input !== "object" || input === null || !("version" in input)) throw new Error("Session version is missing");
+  if (input.version === SESSION_VERSION) return SessionDocumentSchema.parse(input);
+  if (input.version === 3) {
+    const legacy2 = SessionDocumentV3Schema.parse(input);
+    return SessionDocumentSchema.parse({ ...legacy2, version: SESSION_VERSION });
+  }
+  if (input.version === 2) {
+    const legacy2 = SessionDocumentV2Schema.parse(input);
+    return SessionDocumentSchema.parse({
+      ...legacy2,
+      version: SESSION_VERSION,
+      timeline: {
+        version: 1,
+        state: transcriptFromLegacyConversation(legacy2.conversation.messages.filter((message2) => message2.role !== "system"), legacy2.conversation.compact)
+      }
+    });
+  }
+  if (input.version !== 1) throw new Error(`Unsupported session version: ${String(input.version)}`);
+  const legacy = SessionDocumentV1Schema.parse(input);
+  const { conversation, ...metadata } = legacy;
+  const prefix = "Conversation summary\n";
+  const summary = conversation.summary?.content.startsWith(prefix) ? conversation.summary.content.slice(prefix.length).trim() : void 0;
+  const compact = summary === void 0 || summary.length === 0 ? void 0 : { summary, compactedAt: legacy.updatedAt };
+  return SessionDocumentSchema.parse({
+    ...metadata,
+    version: SESSION_VERSION,
+    conversation: {
+      ...compact === void 0 ? {} : { compact },
+      messages: conversation.messages
+    },
+    timeline: {
+      version: 1,
+      state: transcriptFromLegacyConversation(conversation.messages.filter((message2) => message2.role !== "system"), compact)
+    }
+  });
+}
+function isTimelineRecord(value) {
+  return typeof value === "object" && value !== null && value.__timeline === true;
+}
+function timelineFromRecords(header, records) {
+  const value = typeof header === "object" && header !== null ? header : {};
+  const completed = records.filter((record) => "turn" in record).map((record) => record.turn);
+  const activeRecords = records.filter((record) => "active" in record);
+  if (activeRecords.length > 1) throw new Error("Session contains multiple active timeline turns");
+  return {
+    version: value.version,
+    state: {
+      completed,
+      ...activeRecords.length === 0 ? {} : { active: activeRecords[0].active },
+      nextId: value.nextId,
+      ...value.taskSnapshot === void 0 ? {} : { taskSnapshot: value.taskSnapshot }
+    }
+  };
+}
+function isTranscriptState(value) {
+  if (!isRecord(value) || !Array.isArray(value.completed) || !value.completed.every(isTranscriptTurn)) return false;
+  if (!Number.isSafeInteger(value.nextId) || value.nextId < 1) return false;
+  if (value.active !== void 0 && !isTranscriptTurn(value.active)) return false;
+  return value.taskSnapshot === void 0 || isRecord(value.taskSnapshot);
+}
+function isTranscriptTurn(value) {
+  if (!isRecord(value)) return false;
+  if (!Number.isSafeInteger(value.id) || value.id < 1) return false;
+  if (value.kind !== void 0 && value.kind !== "compaction") return false;
+  if (value.submittedAt !== void 0 && typeof value.submittedAt !== "string") return false;
+  if (value.completedAt !== void 0 && typeof value.completedAt !== "string") return false;
+  if (typeof value.prompt !== "string" || typeof value.assistantText !== "string") return false;
+  if (!Array.isArray(value.statusLines) || !value.statusLines.every((line) => typeof line === "string")) return false;
+  if (!Array.isArray(value.blocks) || !value.blocks.every(isTranscriptBlock)) return false;
+  return true;
+}
+function isTranscriptBlock(value) {
+  if (!isRecord(value)) return false;
+  if (value.kind === "text") return typeof value.text === "string";
+  if (value.kind !== "status") return false;
+  if (typeof value.id !== "string" || typeof value.text !== "string") return false;
+  if (!["running", "completed", "failed", "cancelled", "info"].includes(String(value.state))) return false;
+  if (value.tool !== void 0) {
+    if (!isRecord(value.tool) || typeof value.tool.name !== "string" || !("input" in value.tool)) return false;
+    if (value.tool.result !== void 0 && !isRecord(value.tool.result)) return false;
+  }
+  return value.details === void 0 || typeof value.details === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function assertNoSymlink(root, target) {
+  let cursor = resolve(target);
+  const stop = resolve(root);
+  if (!isWithin(stop, cursor)) throw new Error("Session path escapes the workspace");
+  const chain = [];
+  while (cursor !== stop) {
+    chain.push(cursor);
+    cursor = dirname(cursor);
+  }
+  for (const path of chain.reverse()) {
+    try {
+      if ((await lstat(path)).isSymbolicLink()) throw new Error(`Session path contains a symbolic link: ${path}`);
+    } catch (error) {
+      if (!isCode(error, "ENOENT")) throw error;
+    }
+  }
+}
+function isWithin(root, path) {
+  const value = relative(resolve(root), resolve(path));
+  return value === "" || !value.startsWith(`..${sep}`) && value !== ".." && !value.includes(":");
+}
+async function canonical(path) {
+  try {
+    return await realpath(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function isCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function sanitize(input, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof input === "string") {
+    if (/\b(?:authorization|api[_ -]?key|provider[_ -]?key|access[_ -]?token|secret)\s*[:=]/i.test(input)) return "[redacted]";
+    return input.replace(/\bsk-[A-Za-z0-9_-]+\b/g, "[redacted]");
+  }
+  if (Array.isArray(input)) return input.map((item) => sanitize(item, seen));
+  if (typeof input !== "object" || input === null) return input;
+  if (seen.has(input)) return "[redacted circular value]";
+  seen.add(input);
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (/^(?:authorization|proxy-authorization|api[_-]?key|provider[_-]?key|access[_-]?token|secret)$/i.test(key)) continue;
+    output[key] = sanitize(value, seen);
+  }
+  seen.delete(input);
+  return output;
+}
+
+export {
+  TaskGraphSchema,
+  TaskPlanner,
+  modelContentText,
+  modelContentTranscriptText,
+  cloneModelContent,
+  normalizeProviderError,
+  createTaskOutputTool,
+  withTimeout,
+  awaitWithSignal,
+  SubagentResultSchema,
+  subagentResultFromTaskOutput,
+  parseFinalSubagentMessage,
+  SubagentScheduler,
+  TaskPlanSchema,
+  TaskUpdateInputSchema,
+  updatePlanTask,
+  activateNextReadyTask,
+  charWidth,
+  thinkingWindow,
+  createTranscriptState,
+  transcriptReducer,
+  restoreTranscriptState,
+  transcriptCensus,
+  SESSION_VERSION,
+  DEFAULT_MAX_SESSION_BYTES,
+  SessionDocumentSchema,
+  SessionStore
+};