@rebon/cli-linux-x64 0.17.3 → 0.19.0

package/bin/compose-runtime/payload/vendor/dsh/system-prompt.js

@@ -0,0 +1,309 @@
+// packages/core/system-prompt/src/index.ts
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { AnonymousEntries, NamedEntries, ScopedLayers, scopeTarget } from "@deepseek-ai/dsh-scope";
+var PERSONA_SECTION = "deployment:persona";
+var PERSONA_ORDER = 0;
+var VARIABLE_NAME = /^[a-z][a-z0-9_]*$/;
+var GROUP_AT = /^\{\{([^{}]*)\}\}/;
+var TOOL_ORDER_REST = "<unlisted-tools>";
+function validateToolOrder(toolOrder) {
+  if (toolOrder === void 0) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of toolOrder) {
+    if (seen.has(name)) throw new Error(`toolOrder lists "${name}" more than once`);
+    seen.add(name);
+  }
+  if (!seen.has(TOOL_ORDER_REST)) {
+    throw new Error(`toolOrder must contain the "${TOOL_ORDER_REST}" rest entry (where unlisted tools are inserted)`);
+  }
+  return toolOrder;
+}
+function orderTools(tools, toolOrder, knownNames) {
+  const reserved = tools.find((tool) => tool.name === TOOL_ORDER_REST);
+  if (reserved !== void 0) {
+    throw new Error(`tool provider returned reserved tool name "${TOOL_ORDER_REST}" (reserved for toolOrder's rest entry)`);
+  }
+  if (toolOrder === void 0) return tools.sort(compareToolNames);
+  const unknown = toolOrder.filter((name) => name !== TOOL_ORDER_REST && !knownNames.has(name));
+  if (unknown.length > 0) {
+    throw new Error(`toolOrder lists unregistered tool${unknown.length > 1 ? "s" : ""} ${unknown.map((name) => `"${name}"`).join(", ")}; known tools: ${[...knownNames].sort().join(", ") || "(none)"}`);
+  }
+  const listed = new Set(toolOrder);
+  const rest = tools.filter((tool) => !listed.has(tool.name)).sort(compareToolNames);
+  return toolOrder.flatMap((name) => name === TOOL_ORDER_REST ? rest : tools.filter((tool) => tool.name === name));
+}
+function compareToolNames(a, b) {
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+function renderPrompt(assembly) {
+  return assembly.sections.map((section) => interpolate(section, assembly.variables, "section")).filter((text) => text.length > 0).join("\n\n");
+}
+function renderContextSnapshot(assembly) {
+  return joinContextSections(renderContextSections(assembly));
+}
+function joinContextSections(sections) {
+  const body = sections.map((section) => section.text).join("\n\n");
+  if (body.length === 0) return "";
+  return `Current runtime context. This snapshot supersedes earlier runtime-context snapshots.
+
+${body}`;
+}
+function renderContextSections(assembly) {
+  return assembly.contexts.map((context) => ({ name: context.name, text: interpolate(context, assembly.variables, "context") })).filter((section) => section.text.length > 0);
+}
+function interpolate(input, variables, kind) {
+  const text = input.text;
+  let result = "";
+  let last = 0;
+  for (let open = text.indexOf("{{"); open >= 0; open = text.indexOf("{{", last)) {
+    const group = GROUP_AT.exec(text.slice(open));
+    if (group === null) {
+      if (text.indexOf("}}", open + 2) >= 0) {
+        throw new Error(`malformed prompt variable reference at "${text.slice(open, open + 16)}\u2026" in ${kind} "${input.name}" (references are complete simple {{name}} groups)`);
+      }
+      result += text.slice(last, open + 2);
+      last = open + 2;
+      continue;
+    }
+    const name = group[0].slice(2, -2);
+    if (!VARIABLE_NAME.test(name)) {
+      throw new Error(`malformed prompt variable reference "{{${name}}}" in ${kind} "${input.name}" (variable names match ${String(VARIABLE_NAME)})`);
+    }
+    if (!Object.hasOwn(variables, name)) {
+      const known = Object.keys(variables);
+      throw new Error(`unknown prompt variable "{{${name}}}" in ${kind} "${input.name}"; registered variables: ${known.length > 0 ? known.join(", ") : "(none)"}`);
+    }
+    const value = variables[name];
+    if (value === void 0) {
+      throw new Error(`prompt variable "{{${name}}}" has no value for this assembly (${kind} "${input.name}")`);
+    }
+    result += text.slice(last, open) + value;
+    last = open + group[0].length;
+  }
+  return result + text.slice(last);
+}
+var PromptLayer = class {
+  sections;
+  contexts;
+  runtimeContextSuppressors = new AnonymousEntries();
+  toolProviders = new AnonymousEntries();
+  variables;
+  /**
+   * Create one prompt layer with diagnostics specific to its ownership scope.
+   * @param scope - the scoped owner, or `undefined` for global registrations.
+   */
+  constructor(scope) {
+    this.sections = new NamedEntries((name) => new Error(scope === void 0 ? `prompt section "${name}" is already registered (for a per-agent override, register through that agent's \`agent.ctx\` instead)` : `prompt section "${name}" is already registered in this scope`));
+    this.contexts = new NamedEntries((name) => new Error(scope === void 0 ? `prompt context "${name}" is already registered (for a per-agent override, register through that agent's \`agent.ctx\` instead)` : `prompt context "${name}" is already registered in this scope`));
+    this.variables = new NamedEntries((name) => new Error(scope === void 0 ? `prompt variable "${name}" is already registered (for a per-agent value, register through that agent's \`agent.ctx\` instead)` : `prompt variable "${name}" is already registered in this scope`));
+  }
+  /** @returns whether this layer owns no prompt registrations. */
+  isEmpty() {
+    return this.sections.isEmpty() && this.contexts.isEmpty() && this.runtimeContextSuppressors.isEmpty() && this.toolProviders.isEmpty() && this.variables.isEmpty();
+  }
+};
+var SystemPrompt = class extends Service {
+  static Config = z.object({
+    includeHarnessIdentity: z.boolean().default(true),
+    includeRuntimeContext: z.boolean().default(true),
+    persona: z.string().default(""),
+    // Preserve omission because an explicit empty order lacks the rest marker.
+    toolOrder: z.array(z.string()).default(void 0)
+  });
+  layers = new ScopedLayers(
+    (scope) => new PromptLayer(scope),
+    () => {
+      this.ctx.emit("system-prompt/change");
+    }
+  );
+  toolOrder;
+  constructor(ctx, config) {
+    super(ctx, "systemPrompt");
+    this.toolOrder = validateToolOrder(config.toolOrder);
+    if (config.includeHarnessIdentity ?? true) {
+      this.section({
+        name: "harness:identity",
+        order: -100,
+        text: "You are an AI agent powered by DeepSeek Harness."
+      });
+    }
+    this.section({
+      name: PERSONA_SECTION,
+      order: PERSONA_ORDER,
+      // The fallback narrows the optional input type; the schema already defaults it.
+      text: config.persona ?? ""
+    });
+    if (!(config.includeRuntimeContext ?? true)) this.suppressRuntimeContext();
+  }
+  /**
+   * Register an ordered prompt section in the calling context's scope. A scoped
+   * section shadows a global section with the same name; duplicates within one
+   * layer and non-finite orders throw. Registration and disposal emit
+   * `system-prompt/change`.
+   * @param section - the section to register.
+   * @returns the exact Cordis effect disposer.
+   */
+  section(section) {
+    if (!Number.isFinite(section.order)) {
+      throw new TypeError(`prompt section "${section.name}" order must be a finite number`);
+    }
+    return this.layers.effect(
+      this.ctx,
+      (layer) => layer.sections.insert(section.name, section),
+      { label: "systemPrompt.section()" }
+    );
+  }
+  /**
+   * Register ordered dynamic context in the calling context's scope. Scoped
+   * entries shadow global entries with the same name.
+   * @param context - the context contribution to register.
+   * @returns the exact Cordis effect disposer.
+   */
+  context(context) {
+    if (!Number.isFinite(context.order)) {
+      throw new TypeError(`prompt context "${context.name}" order must be a finite number`);
+    }
+    return this.layers.effect(
+      this.ctx,
+      (layer) => layer.contexts.insert(context.name, context),
+      { label: "systemPrompt.context()" }
+    );
+  }
+  /**
+   * Suppress every dynamic runtime-context contribution in the calling
+   * context's scope without changing the services that own or enforce those
+   * facts. Multiple suppressors remain independently disposable.
+   * @returns the exact Cordis effect disposer.
+   */
+  suppressRuntimeContext() {
+    return this.layers.effect(
+      this.ctx,
+      (layer) => layer.runtimeContextSuppressors.append(true),
+      { label: "systemPrompt.suppressRuntimeContext()" }
+    );
+  }
+  /**
+   * Register a tool-schema provider in the calling context's scope. Global and
+   * matching scoped providers both contribute; returning the reserved
+   * {@link TOOL_ORDER_REST} name makes assembly fail.
+   * @param provider - evaluated for each assembly with its context.
+   * @returns the exact Cordis effect disposer.
+   */
+  tools(provider) {
+    return this.layers.effect(
+      this.ctx,
+      (layer) => layer.toolProviders.append(provider),
+      { label: "systemPrompt.tools()" }
+    );
+  }
+  /**
+   * Register a prompt variable in the calling context's scope. Scoped values
+   * shadow globals; invalid or duplicate names throw. A provider may return
+   * `undefined`, but rendering a section that references that value then fails.
+   * @param name - the `[a-z][a-z0-9_]*` reference name.
+   * @param provider - evaluated for each assembly.
+   * @returns the exact Cordis effect disposer.
+   */
+  variable(name, provider) {
+    if (!VARIABLE_NAME.test(name)) {
+      throw new Error(`invalid prompt variable name "${name}" (must match ${String(VARIABLE_NAME)})`);
+    }
+    return this.layers.effect(
+      this.ctx,
+      (layer) => layer.variables.insert(name, provider),
+      { label: "systemPrompt.variable()" }
+    );
+  }
+  /**
+   * Assemble global and scoped providers, detach tool parameters, apply
+   * canonical ordering, then run the assembly waterfall. Scoped sections and
+   * variables shadow globals. The returned waterfall value is authoritative
+   * except that an effective complete section is restored afterwards as the
+   * sole prompt section.
+   * @param context - the optional scope and plugin-defined assembly fields.
+   * @returns the post-waterfall assembly with any complete prompt enforced.
+   */
+  // Keep configuration failures on the declared asynchronous error path.
+  async assemble(context = {}) {
+    const scope = context.scope;
+    const scopeLayers = this.layers.chainLayers(scope);
+    const runtimeContextSuppressed = !this.layers.global.runtimeContextSuppressors.isEmpty() || scopeLayers.some((layer) => !layer.runtimeContextSuppressors.isEmpty());
+    const variables = {};
+    for (const [name, provider] of this.layers.global.variables.entries()) {
+      variables[name] = provider(context);
+    }
+    for (const layer of scopeLayers) {
+      for (const [name, provider] of layer.variables.entries()) {
+        variables[name] = provider(context);
+      }
+    }
+    const sectionByName = this.layers.merge(scope, (layer) => layer.sections);
+    const contextByName = this.layers.merge(scope, (layer) => layer.contexts);
+    const providers = [
+      ...this.layers.global.toolProviders.values(),
+      ...scopeLayers.flatMap((layer) => [...layer.toolProviders.values()])
+    ];
+    const collected = [];
+    const knownNames = /* @__PURE__ */ new Set();
+    for (const provider of providers) {
+      const result = provider(context);
+      const schemas = result.schemas.map(({ name, description, parameters }) => ({
+        name,
+        description,
+        parameters: structuredClone(parameters)
+      }));
+      const acceptedKnownNames = result.knownNames ?? schemas.map((tool) => tool.name);
+      collected.push(...schemas);
+      for (const name of acceptedKnownNames) knownNames.add(name);
+    }
+    const sectionDefinitions = [...sectionByName.values()].sort((a, b) => a.order - b.order);
+    const completeSections = sectionDefinitions.filter((section) => section.complete === true);
+    if (completeSections.length > 1) {
+      throw new Error(`multiple complete prompt sections are active: ${completeSections.map((section) => JSON.stringify(section.name)).join(", ")}`);
+    }
+    let completeSection;
+    const sections = sectionDefinitions.map((section) => {
+      const assembled = {
+        name: section.name,
+        text: typeof section.text === "function" ? section.text(context) : section.text
+      };
+      if (section.complete === true) completeSection = { ...assembled };
+      return assembled;
+    });
+    const assembly = {
+      sections,
+      contexts: runtimeContextSuppressed ? [] : [...contextByName.values()].sort((a, b) => a.order - b.order).map((entry) => ({
+        name: entry.name,
+        text: typeof entry.text === "function" ? entry.text(context) : entry.text
+      })),
+      tools: orderTools(collected, this.toolOrder, knownNames),
+      variables
+    };
+    const transformed = await this.ctx.waterfall(
+      scopeTarget(this, scope),
+      "system-prompt/assemble",
+      assembly,
+      context,
+      () => Promise.resolve(assembly)
+    );
+    if (completeSection === void 0 && !runtimeContextSuppressed) return transformed;
+    return {
+      ...transformed,
+      sections: completeSection === void 0 ? transformed.sections : [completeSection],
+      contexts: runtimeContextSuppressed ? [] : transformed.contexts
+    };
+  }
+};
+var index_default = SystemPrompt;
+export {
+  PERSONA_ORDER,
+  PERSONA_SECTION,
+  SystemPrompt,
+  TOOL_ORDER_REST,
+  index_default as default,
+  joinContextSections,
+  renderContextSections,
+  renderContextSnapshot,
+  renderPrompt
+};

package/bin/compose-runtime/payload/vendor/dsh/timeout.js

@@ -0,0 +1,100 @@
+// packages/util/timeout/src/index.ts
+var TimeoutReason = class extends Error {
+  /**
+   * @param code Capability-owned timeout code (e.g. `BASH_TIMEOUT`).
+   * @param timeoutMs The deadline that elapsed, in milliseconds.
+   */
+  constructor(code, timeoutMs) {
+    super(`${code} after ${timeoutMs}ms`);
+    this.code = code;
+    this.timeoutMs = timeoutMs;
+  }
+  code;
+  timeoutMs;
+  name = "TimeoutReason";
+};
+var MAX_TIMER_DELAY_MS = 2147483647;
+function assertTimerDelay(timeoutMs, name) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_DELAY_MS) {
+    throw new Error(`${name} must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  }
+}
+function clampTimeout(requested, def, max, name = "timeoutMs") {
+  if (requested !== void 0 && (!Number.isFinite(requested) || requested <= 0)) {
+    throw new Error(`${name} must be a positive finite number`);
+  }
+  return Math.min(requested ?? def, max);
+}
+function deadline(upstream, timeoutMs, code) {
+  if (timeoutMs <= 0) {
+    return { signal: upstream ?? new AbortController().signal, [Symbol.dispose]() {
+    } };
+  }
+  assertTimerDelay(timeoutMs, "deadline timeoutMs");
+  const timer = new AbortController();
+  const id = setTimeout(() => {
+    timer.abort(new TimeoutReason(code, timeoutMs));
+  }, timeoutMs);
+  return {
+    // AbortSignal.any adopts the reason of whichever source aborts FIRST, so a
+    // race resolves to a single cause: timeoutOf() reads TimeoutReason only
+    // when the timeout won, and upstream-wins leaves an ordinary abort reason.
+    signal: upstream !== void 0 ? AbortSignal.any([upstream, timer.signal]) : timer.signal,
+    [Symbol.dispose]() {
+      clearTimeout(id);
+    }
+  };
+}
+function idleWatchdog(upstream, timeoutMs, code) {
+  assertTimerDelay(timeoutMs, "idleWatchdog timeoutMs");
+  const timeout = new AbortController();
+  const signal = upstream === void 0 ? timeout.signal : AbortSignal.any([upstream, timeout.signal]);
+  let timer;
+  let outstanding = false;
+  let disposed = false;
+  const arm = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timeout.abort(new TimeoutReason(code, timeoutMs));
+    }, timeoutMs);
+  };
+  return {
+    signal,
+    async next(iterator) {
+      if (disposed) throw new Error("idleWatchdog is disposed");
+      if (outstanding) throw new Error("idleWatchdog next is already outstanding");
+      outstanding = true;
+      arm();
+      try {
+        return await iterator.next();
+      } finally {
+        clearTimeout(timer);
+        timer = void 0;
+        outstanding = false;
+      }
+    },
+    pulse() {
+      if (disposed || !outstanding) return;
+      arm();
+    },
+    [Symbol.dispose]() {
+      if (disposed) return;
+      disposed = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+}
+function timeoutOf(x, code) {
+  const reason = x.reason;
+  if (!(reason instanceof TimeoutReason)) return void 0;
+  return code === void 0 || reason.code === code ? reason : void 0;
+}
+export {
+  MAX_TIMER_DELAY_MS,
+  TimeoutReason,
+  clampTimeout,
+  deadline,
+  idleWatchdog,
+  timeoutOf
+};

package/bin/compose-runtime/payload/vendor/dsh/timer.js

@@ -0,0 +1,128 @@
+// dsh-vendor/timer/src/index.ts
+import { Service } from "@deepseek-ai/cordis";
+var TimerService = class extends Service {
+  constructor(ctx) {
+    super(ctx, "timer");
+    ctx.mixin("timer", ["timeout", "interval", "throttle", "debounce", "setTimeout", "setInterval"]);
+  }
+  /** @deprecated use `ctx.timeout()` instead */
+  setTimeout(callback, delay) {
+    return this.timeout(callback, delay);
+  }
+  /** @deprecated use `ctx.interval()` instead */
+  setInterval(callback, delay) {
+    return this.interval(callback, delay);
+  }
+  timeout(...args) {
+    const callback = typeof args[0] === "function" ? args.shift() : void 0;
+    const delay = args[0];
+    if (callback) {
+      const dispose = this.ctx.effect(() => {
+        const timer = setTimeout(() => {
+          dispose();
+          callback();
+        }, delay);
+        return () => clearTimeout(timer);
+      }, "ctx.timeout()");
+      return dispose;
+    } else {
+      const { promise, resolve, reject } = Promise.withResolvers();
+      const dispose = this.ctx.effect(() => {
+        const timer = setTimeout(resolve, delay);
+        return () => {
+          clearTimeout(timer);
+          reject(new Error("Context has been disposed"));
+        };
+      }, "ctx.timeout()");
+      return promise.finally(dispose);
+    }
+  }
+  interval(...args) {
+    const callback = typeof args[0] === "function" ? args.shift() : void 0;
+    const delay = args[0];
+    if (callback) {
+      return this.ctx.effect(() => {
+        const timer = setInterval(callback, delay);
+        return () => clearInterval(timer);
+      }, "ctx.interval()");
+    } else {
+      let done;
+      let nextTask;
+      const dispose = this.ctx.effect(() => {
+        const timer = setInterval(() => {
+          nextTask?.resolve({ done: false, value: void 0 });
+        }, delay);
+        return () => {
+          clearInterval(timer);
+          if (done) return;
+          done = { kind: "throw", reason: new Error("Context has been disposed") };
+          nextTask?.reject(done.reason);
+        };
+      }, "ctx.interval()");
+      return {
+        next: () => {
+          if (!done) return (nextTask = Promise.withResolvers()).promise;
+          if (done.kind === "return") return Promise.resolve({ done: true, value: done.value });
+          return Promise.reject(done.reason);
+        },
+        return: (value) => {
+          if (!done) done = { kind: "return", value };
+          nextTask?.resolve({ done: true, value });
+          dispose();
+          return Promise.resolve({ done: true, value });
+        },
+        throw: (reason) => {
+          if (!done) done = { kind: "throw", reason };
+          nextTask?.reject(reason);
+          dispose();
+          return Promise.resolve({ done: true, value: void 0 });
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  }
+  _schedule(label, trigger, isDisposed = false) {
+    let timer;
+    const dispose = this.ctx.effect(() => () => {
+      isDisposed = true;
+      clearTimeout(timer);
+    }, label);
+    const wrapper = (...args) => {
+      clearTimeout(timer);
+      timer = trigger(args, isDisposed);
+    };
+    wrapper.dispose = dispose;
+    return wrapper;
+  }
+  /** Return a throttled function whose timer is disposed with the current fiber. */
+  throttle(callback, delay, noTrailing) {
+    let lastCall = -Infinity;
+    const execute = (...args) => {
+      lastCall = Date.now();
+      callback(...args);
+    };
+    return this._schedule("ctx.throttle()", (args, isDisposed) => {
+      const now = Date.now();
+      const remaining = delay - now + lastCall;
+      if (remaining <= 0) {
+        execute(...args);
+      } else if (!isDisposed) {
+        return setTimeout(execute, remaining, ...args);
+      }
+    }, noTrailing);
+  }
+  /** Return a debounced function whose timer is disposed with the current fiber. */
+  debounce(callback, delay) {
+    return this._schedule("ctx.debounce()", (args, isDisposed) => {
+      if (isDisposed) return;
+      return setTimeout(callback, delay, ...args);
+    });
+  }
+};
+var index_default = TimerService;
+export {
+  TimerService,
+  index_default as default
+};

package/bin/compose-runtime/payload/vendor/dsh/tool-todo.js

@@ -0,0 +1,143 @@
+// packages/todo/tool-todo/src/index.ts
+import z from "@deepseek-ai/schemastery";
+import { z as zod } from "zod";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+var name = "tool-todo";
+var inject = ["tools"];
+var STATUSES = ["pending", "in_progress", "completed"];
+var Config = z.object({
+  allowParallelInProgress: z.boolean().required()
+});
+var DESCRIPTION_HEAD = "Record and update a structured task list for the current work. Send the ENTIRE list every call \u2014 it REPLACES the previous list (there are no partial updates, no per-item edits). Use it to plan multi-step work and show progress: add one todo per concrete step before you start. ";
+var DESCRIPTION_PARALLEL = "Mark every todo being actively worked on `in_progress` \u2014 several at once when work genuinely runs in parallel (e.g. concurrent subagents or background commands), one for sequential work; while work remains, at least one task should be `in_progress`. ";
+var DESCRIPTION_SINGLE = "Keep AT MOST ONE todo `in_progress` at a time; while work remains, exactly one active task should be `in_progress`. ";
+var DESCRIPTION_TAIL = "Mark a todo `completed` the moment it is done (do not batch completions), and allow no `in_progress` item only once all work is complete. Skip the list for trivial single-step tasks. Statuses: `pending` (not started), `in_progress` (being worked on now), `completed` (finished).";
+function describe(allowParallel) {
+  return DESCRIPTION_HEAD + (allowParallel ? DESCRIPTION_PARALLEL : DESCRIPTION_SINGLE) + DESCRIPTION_TAIL;
+}
+function toTodoList(raw, allowParallel) {
+  const todos = [];
+  const seen = /* @__PURE__ */ new Set();
+  let active = 0;
+  for (const item of raw) {
+    const content = item.content.trim();
+    if (content.length === 0) {
+      throw new Error("invalid todo: `content` must be a non-empty string");
+    }
+    if (seen.has(content)) {
+      throw new Error(`invalid todos: duplicate content ${JSON.stringify(content)}`);
+    }
+    seen.add(content);
+    if (item.status === "in_progress") active++;
+    todos.push({ content, status: item.status });
+  }
+  if (!allowParallel && active > 1) {
+    throw new Error(`invalid todos: at most one task may be in_progress (got ${active})`);
+  }
+  return todos;
+}
+var todosProjectionSchema = zod.union([
+  zod.array(zod.object({
+    content: zod.string(),
+    status: zod.union([zod.literal("pending"), zod.literal("in_progress"), zod.literal("completed")])
+  })),
+  zod.null()
+]);
+function apply(ctx, config) {
+  const allowParallel = config.allowParallelInProgress;
+  ctx.inject(["sessionProjections"], (projectionCtx) => {
+    projectionCtx.sessionProjections.register({
+      key: "todos",
+      schema: todosProjectionSchema,
+      init: () => null,
+      apply: (state, event) => {
+        if (event.type === "todo/write") return event.data.todos;
+        if (event.type === "turn/start") return null;
+        return state;
+      },
+      view: (state) => state,
+      stateVersion: 2
+    });
+  });
+  ctx.tools.register(defineTool({
+    name: "todo_write",
+    description: describe(allowParallel),
+    parameters: {
+      todos: {
+        type: "array",
+        required: true,
+        description: "The COMPLETE task list, replacing any previous list.",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            content: { type: "string", required: true, description: "What the task is \u2014 a short imperative line." },
+            status: {
+              type: "string",
+              required: true,
+              enum: [...STATUSES],
+              description: "pending (not started) | in_progress (now) | completed (done)."
+            }
+          }
+        }
+      }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          todos: {
+            type: "array",
+            required: true,
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                content: { type: "string", required: true },
+                status: { type: "string", required: true, enum: [...STATUSES] }
+              }
+            }
+          },
+          counts: {
+            type: "object",
+            additionalProperties: false,
+            required: true,
+            properties: {
+              pending: { type: "integer", required: true },
+              inProgress: { type: "integer", required: true },
+              completed: { type: "integer", required: true }
+            }
+          }
+        }
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: `Updated todo list: ${value.counts.pending} pending, ${value.counts.inProgress} in progress, ${value.counts.completed} completed.`
+      }]
+    },
+    execute(args, exec) {
+      const todos = toTodoList(args.todos, allowParallel);
+      if (!exec.agent) {
+        throw new Error("todo_write requires an owning agent session");
+      }
+      exec.agent.session.append("todo/write", { todos });
+      const count = (status) => todos.filter((t) => t.status === status).length;
+      return Promise.resolve({
+        todos: todos.map((todo) => ({ content: todo.content, status: todo.status })),
+        counts: {
+          pending: count("pending"),
+          inProgress: count("in_progress"),
+          completed: count("completed")
+        }
+      });
+    },
+    presentCall: (args) => ({ card: "generic", title: "Update todo list", kind: "other", rawInput: args.todos })
+  }));
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};