@letta-ai/letta-code 0.33.1 → 0.33.2

package/skills/initializing-memory/scripts/history-coverage.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// Account for every exported session after the analysis Workflow ran.
+// Compares the cohorts and ledger written by prepare-history.mjs against the
+// Workflow journal(s): a session counts as analyzed only when some history
+// subagent returned JSON whose `sessionsRead` array names its sessionId.
+//
+// Usage:
+//   node history-coverage.mjs --prepared <dir> --journal <journal.jsonl>
+//     [--journal <journal.jsonl> ...] [--retry-out <file>] [--retry-size 5]
+//
+// Prints a coverage report. With --retry-out, writes { historyCohorts } with
+// the unread sessions split into smaller cohorts for a follow-up Workflow run.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+const USAGE =
+  "Usage: history-coverage.mjs --prepared <dir> --journal <journal.jsonl> [--journal ...] [--retry-out <file>] [--retry-size N]";
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function readJson(path) {
+  if (!existsSync(path))
+    fail(`Missing ${path}; run prepare-history.mjs first.`);
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function readSessionsRead(journalPath) {
+  if (!existsSync(journalPath)) fail(`Missing journal ${journalPath}`);
+  const read = new Set();
+  for (const line of readFileSync(journalPath, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const value = entry?.outcome?.failed ? null : entry?.outcome?.value;
+    if (value && Array.isArray(value.sessionsRead)) {
+      for (const id of value.sessionsRead) {
+        if (typeof id === "string") read.add(id);
+      }
+    }
+  }
+  return read;
+}
+
+const { values } = parseArgs({
+  options: {
+    prepared: { type: "string" },
+    journal: { type: "string", multiple: true },
+    "retry-out": { type: "string" },
+    "retry-size": { type: "string", default: "5" },
+    help: { type: "boolean", short: "h" },
+  },
+});
+
+if (values.help) {
+  console.log(USAGE);
+  process.exit(0);
+}
+if (!values.prepared || !values.journal?.length) fail(USAGE);
+const retrySize = Number(values["retry-size"]);
+if (!Number.isSafeInteger(retrySize) || retrySize < 1) {
+  fail("--retry-size must be a positive integer");
+}
+
+const preparedDir = resolve(values.prepared);
+const { historyCohorts } = readJson(join(preparedDir, "cohorts.json"));
+const ledger = readJson(join(preparedDir, "ledger.json"));
+
+const read = new Set();
+for (const journal of values.journal) {
+  for (const id of readSessionsRead(resolve(journal))) read.add(id);
+}
+
+const unread = [];
+let analyzed = 0;
+for (const cohort of historyCohorts) {
+  const missing = cohort.sessions.filter((s) => !read.has(s.sessionId));
+  analyzed += cohort.sessions.length - missing.length;
+  if (missing.length)
+    unread.push({ cohort: cohort.id, repo: cohort.repo, sessions: missing });
+}
+
+const unreadCount = unread.reduce((n, c) => n + c.sessions.length, 0);
+const inCohorts = analyzed + unreadCount;
+// Sessions the ledger assigned but that were later dropped from cohorts.json
+// (for example deprioritized by hand) were never sent to the Workflow.
+const droppedFromCohorts = Math.max(0, ledger.assigned - inCohorts);
+const report = {
+  manifestSessions: ledger.manifestSessions,
+  exportErrors: ledger.exportErrors.length,
+  excluded: ledger.excluded.length,
+  droppedFromCohorts,
+  analyzed,
+  unread: unread.map((c) => ({
+    cohort: c.cohort,
+    sessionIds: c.sessions.map((s) => s.sessionId),
+  })),
+  allAssignedRead: unreadCount === 0 && droppedFromCohorts === 0,
+};
+
+if (values["retry-out"]) {
+  const retryCohorts = [];
+  for (const cohort of unread) {
+    for (let i = 0; i < cohort.sessions.length; i += retrySize) {
+      retryCohorts.push({
+        id: `${cohort.cohort}-retry-${i / retrySize + 1}`,
+        repo: cohort.repo,
+        sessions: cohort.sessions.slice(i, i + retrySize),
+      });
+    }
+  }
+  const retryPath = resolve(values["retry-out"]);
+  writeFileSync(
+    retryPath,
+    `${JSON.stringify({ historyCohorts: retryCohorts }, null, 2)}\n`,
+  );
+  report.retryFile = retryPath;
+  report.retryCohorts = retryCohorts.length;
+}
+
+console.log(JSON.stringify(report, null, 2));

package/skills/initializing-memory/scripts/prepare-history.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// Turn a `letta trajectories export` directory into Workflow-ready history
+// cohorts: render every session to plain text (Workflow subagents only have
+// Read/Grep/Glob), group sessions into size-bounded cohorts per project, and
+// record a coverage ledger of everything that was excluded and why.
+//
+// Usage:
+//   node prepare-history.mjs --export <dir> --out <dir>
+//     [--max-bytes 200000] [--max-sessions 20]
+//     [--letta <executable>] [--letta-arg <argument> ...]
+//
+// Writes <out>/rendered/<source>/<session>.txt, <out>/cohorts.json
+// ({ historyCohorts }) and <out>/ledger.json, and prints a summary.
+
+import { spawnSync } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+const USAGE =
+  "Usage: prepare-history.mjs --export <dir> --out <dir> [--max-bytes N] [--max-sessions N] [--letta executable] [--letta-arg argument ...]";
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function positiveInt(value, name) {
+  const n = Number(value);
+  if (!Number.isSafeInteger(n) || n < 1)
+    fail(`--${name} must be a positive integer`);
+  return n;
+}
+
+function slug(value) {
+  return (
+    value
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "session"
+  );
+}
+
+function render(lettaCmd, exportDir, file, path) {
+  const [bin, ...prefix] = lettaCmd;
+  // Bun can exit before flushing a large console.log to a pipe. Redirect to a
+  // regular file so a successful CLI exit cannot silently truncate history.
+  const fd = openSync(path, "w");
+  let result;
+  try {
+    result = spawnSync(
+      bin,
+      [...prefix, "trajectories", "view", file, "--out", exportDir, "--tools"],
+      { encoding: "utf8", stdio: ["ignore", fd, "pipe"] },
+    );
+  } finally {
+    closeSync(fd);
+  }
+  if (result.error || result.status !== 0) rmSync(path, { force: true });
+  if (result.error) return { error: result.error.message };
+  if (result.status !== 0) {
+    return { error: (result.stderr || `exit ${result.status}`).trim() };
+  }
+  return { bytes: statSync(path).size };
+}
+
+function buildCohorts(sessions, maxBytes, maxSessions) {
+  const byProject = new Map();
+  for (const session of sessions) {
+    const key = session.project ?? "";
+    if (!byProject.has(key)) byProject.set(key, []);
+    byProject.get(key).push(session);
+  }
+
+  const cohorts = [];
+  const usedIds = new Set();
+  for (const [project, list] of byProject) {
+    list.sort((a, b) => (a.startedAt ?? "").localeCompare(b.startedAt ?? ""));
+    let current = [];
+    let bytes = 0;
+    const flush = () => {
+      if (current.length === 0) return;
+      const base = `${slug(project ? basename(project) : "unknown-project")}-${(current[0].startedAt ?? "undated").slice(0, 10)}`;
+      let id = base;
+      for (let n = 2; usedIds.has(id); n++) id = `${base}-${n}`;
+      usedIds.add(id);
+      cohorts.push({
+        id,
+        repo: project && existsSync(project) ? project : null,
+        sessions: current,
+      });
+      current = [];
+      bytes = 0;
+    };
+    for (const session of list) {
+      if (
+        current.length > 0 &&
+        (bytes + session.renderedBytes > maxBytes ||
+          current.length >= maxSessions)
+      ) {
+        flush();
+      }
+      current.push(session);
+      bytes += session.renderedBytes;
+    }
+    flush();
+  }
+
+  return cohorts.map((cohort) => ({
+    ...cohort,
+    sessions: cohort.sessions.map(({ renderedBytes: _bytes, ...rest }) => rest),
+  }));
+}
+
+const { values } = parseArgs({
+  options: {
+    export: { type: "string" },
+    out: { type: "string" },
+    "max-bytes": { type: "string", default: "200000" },
+    "max-sessions": { type: "string", default: "20" },
+    letta: { type: "string", default: "letta" },
+    "letta-arg": { type: "string", multiple: true },
+    help: { type: "boolean", short: "h" },
+  },
+});
+
+if (values.help) {
+  console.log(USAGE);
+  process.exit(0);
+}
+if (!values.export || !values.out) fail(USAGE);
+
+const exportDir = resolve(values.export);
+const outDir = resolve(values.out);
+const maxBytes = positiveInt(values["max-bytes"], "max-bytes");
+const maxSessions = positiveInt(values["max-sessions"], "max-sessions");
+const lettaCmd = [values.letta, ...(values["letta-arg"] ?? [])];
+
+const manifestPath = join(exportDir, "manifest.json");
+if (!existsSync(manifestPath)) {
+  fail(
+    `No manifest at ${manifestPath}. Run: letta trajectories export --out ${exportDir}`,
+  );
+}
+const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+const excluded = [];
+const rendered = [];
+for (const entry of manifest.sessions ?? []) {
+  const ref = {
+    sessionId: entry.sessionId,
+    source: entry.source,
+    file: entry.file,
+  };
+  if (!entry.userMessages) {
+    excluded.push({ ...ref, reason: "no user messages" });
+    continue;
+  }
+  const path = join(outDir, "rendered", entry.file.replace(/\.json$/, ".txt"));
+  mkdirSync(dirname(path), { recursive: true });
+  const result = render(lettaCmd, exportDir, entry.file, path);
+  if (result.error) {
+    excluded.push({ ...ref, reason: `render failed: ${result.error}` });
+    continue;
+  }
+  rendered.push({
+    sessionId: entry.sessionId,
+    path,
+    source: entry.source,
+    project: entry.project ?? null,
+    startedAt: entry.startedAt ?? null,
+    userMessages: entry.userMessages,
+    renderedBytes: result.bytes,
+  });
+}
+
+const historyCohorts = buildCohorts(rendered, maxBytes, maxSessions);
+const ledger = {
+  exportDir,
+  manifestSessions: (manifest.sessions ?? []).length,
+  exportErrors: manifest.errors ?? [],
+  assigned: rendered.length,
+  excluded,
+};
+
+mkdirSync(outDir, { recursive: true });
+writeFileSync(
+  join(outDir, "cohorts.json"),
+  `${JSON.stringify({ historyCohorts }, null, 2)}\n`,
+);
+writeFileSync(
+  join(outDir, "ledger.json"),
+  `${JSON.stringify(ledger, null, 2)}\n`,
+);
+
+console.log(
+  JSON.stringify(
+    {
+      cohorts: historyCohorts.length,
+      manifestSessions: ledger.manifestSessions,
+      assigned: ledger.assigned,
+      excluded: excluded.length,
+      exportErrors: ledger.exportErrors.length,
+      cohortsFile: join(outDir, "cohorts.json"),
+      ledgerFile: join(outDir, "ledger.json"),
+    },
+    null,
+    2,
+  ),
+);

package/skills/scheduling-tasks/SKILL.md

@@ -1,39 +1,31 @@
 ---
 name: scheduling-tasks
-description: Advanced scheduling through the letta cron CLI for other conversations, runners, computers, run history, and schedule replacement. Use Wake for ordinary create/list/cancel operations in the current conversation.
+description: Advanced scheduling through the letta cron CLI for other conversations, computers, run history, and schedule replacement. Use Wake for ordinary create/list/cancel operations in the current conversation.
 ---
 
 # Scheduling Tasks
 
 This skill lets you create, list, and manage scheduled tasks using the `letta cron` CLI. Scheduled tasks send a prompt to the agent on a timer — useful for reminders, periodic check-ins, and deferred follow-ups.
 
-For ordinary one-shot or recurring work in the current conversation, use Wake instead. Wake is self-bound and covers create, list, and cancel without runner or routing choices.
+For ordinary one-shot or recurring work in the current conversation, use Wake instead. Wake is self-bound and covers create, list, and cancel without routing choices.
 
 ## When to Use This Skill
 
 - The task should run in a fresh, default, or different conversation
-- The task needs a specific local or Cloud runner or connected computer
+- The task needs a specific connected computer
 - You need run history, replacement, or broader schedule inspection
 - Wake cannot see or manage the schedule you need
 
-## Where Schedules Run — Omit the Flags
+## Where Schedules Run
 
-**Default guidance: omit `--runner` and `--computer`.** The CLI places the schedule so the work keeps running on the computer where it was created. Don't move scheduled work to a different computer than the active conversation without a reason: two computers working the same conversation can conflict.
+Execution determines schedule ownership; there is no runner selection flag:
 
-Pass a flag only when you have a requirement the default can't infer:
+- In a managed Cloud sandbox, schedules are durable Cloud schedules and run in the agent's Cloud sandbox.
+- On a user-managed computer or self-hosted runtime, schedules are local and fire only while a Letta session is running there.
 
-- **`--runner cloud`** — the schedule must fire no matter which computers are online; execute in the agent's cloud sandbox.
-- **`--computer <deviceId>`** — the work needs a specific connected computer (its filesystem, services, or credentials). Get the deviceId from `letta computers list`. If that computer is offline at fire time, execution falls back to the cloud sandbox.
-- **`--runner local`** — the work must only ever run on the current computer, even if that means missing fires while no session is running here.
+From a managed Cloud sandbox, `--computer <deviceId>` can run the scheduled work on a specific connected computer. Get the device ID from `letta computers list`. If that computer is offline at fire time, execution falls back to the Cloud sandbox. Local execution cannot target another computer.
 
-The CLI reports its placement in the command output. If it warns that the schedule is local (this happens when the cloud scheduler cannot reach the current computer), the schedule only fires while a Letta session is running here — read the warning and decide whether that's acceptable.
-
-### Fast Follow-ups vs Recurring Jobs
-
-Two patterns cover most schedules:
-
-- **Fast follow-ups** ("check on the PR in 5m"): the default is right — same computer as the active conversation. If the session dies before it fires, the follow-up usually died with the task anyway.
-- **Recurring jobs** ("every Monday 11am, start the lunch order"): prefer durability. If the CLI warned that a recurring schedule is local, that's usually wrong for the user's intent — recreate it with `--runner cloud`, or `--computer` if the job needs a specific always-on computer. A fresh conversation per run is the default; pass a conversation explicitly when the job needs continuity in one thread.
+Creation and execution follow those rules, while management commands still show and cancel both local and Cloud inventory. This keeps schedules created by older CLI versions visible without changing where new schedules run.
 
 ## CLI Usage
 
@@ -67,8 +59,7 @@ letta cron add --name <short-name> --description <text> --prompt <text> <schedul
 |------|-------------|
 | `--agent <id>` | Agent ID (defaults to `LETTA_AGENT_ID` from the current shell/session) |
 | `--conversation <id>` | Conversation target: omit or pass `new` for a fresh conversation per fire; pass `self` for the current conversation; pass `default` for the agent default; or pass a concrete ID |
-| `--runner <runner>` | `cloud` or `local` — normally omit; see "Where Schedules Run" above |
-| `--computer <id>` | Execute on a specific connected computer — normally omit |
+| `--computer <id>` | From managed Cloud, execute on a specific connected computer |
 | `--once` | Mark `--at` as one-shot (already the default for `--at`) |
 
 ### Listing Tasks
@@ -77,20 +68,20 @@ letta cron add --name <short-name> --description <text> --prompt <text> <schedul
 letta cron list
 ```
 
-Optional filters: `--agent <id>`, `--conversation <id>`, `--runner local|cloud`
+Optional filters: `--agent <id>`, `--conversation <id>`
 
 ### Getting a Single Task
 
 `get` accepts an ID or name:
 
 ```bash
-letta cron get <id-or-name> [--runner local|cloud] [--agent <id>]
+letta cron get <id-or-name> [--agent <id>]
 ```
 
 ### Reading Run History
 
 ```bash
-letta cron runs --id <task-id> [--limit <n>] [--runner local|cloud] [--agent <id>]
+letta cron runs --id <task-id> [--limit <n>] [--agent <id>]
 ```
 
 For local run history, `--run-id <id>` selects one run. Cloud history ignores that flag.
@@ -125,7 +116,7 @@ letta cron list --agent "$LETTA_AGENT_ID" --conversation self
 
 ```bash
 # Delete a specific task
-letta cron delete <id-or-name> [--runner local|cloud] [--agent <id>]
+letta cron delete <id-or-name> [--agent <id>]
 
 # Delete all tasks for one agent
 letta cron delete --all --agent "$AGENT_ID"
@@ -212,7 +203,7 @@ Include context about what the user originally asked for, so you can give a help
 - **Default binding**: `letta cron add` uses `--agent` first, then `LETTA_AGENT_ID`. Omit `--conversation` for a fresh conversation per fire; use `--conversation self` to capture `LETTA_CONVERSATION_ID` explicitly.
 - **Local scheduler requirement**: Local schedules only fire while a Letta session is running on their computer; fires while no session runs are marked as missed. Cloud schedules fire from the cloud regardless.
 - **`--at` for specific times**: prefer RFC 3339 with an explicit offset. A bare `--at "3:00pm"` uses the process timezone and schedules tomorrow if that time has already passed there.
-- **Cloud schedule creation failures are loud**: if creating a cloud schedule fails, no schedule is created — a failed create never silently becomes a local schedule. (The local placement for computers the cloud scheduler can't reach is decided before creation and reported in the output.)
+- **Cloud schedule creation failures are loud**: if creating a Cloud schedule fails in a managed Cloud sandbox, no schedule is created; it never falls back to a local schedule.
 
 ## Cron Expression Reference
 

package/skills/workflow-authoring/SKILL.md

@@ -69,11 +69,12 @@ Workflow subagents require the API backend.
 ## Script body hooks
 
 - `agent(prompt, opts?)` → Promise. Spawn one subagent. Resolves to its final
-  text, or with `json: true` to the parsed JSON value (say in the prompt what
-  shape to return — nothing validates it; a reply that is not JSON resolves to
-  `null`). Resolves to `null` on any failure — filter with `.filter(Boolean)`.
-  Options: `label` (display name), `phase` (progress group — use this inside
-  pipeline()/parallel() stages to avoid races on the global phase() state),
+  text, or with `schema` (JSON Schema) to a validated object. Prefer `schema`
+  for shaped results: invalid or missing output is retried, then resolves to
+  `null` with validation detail in the journal. `json: true` still parses
+  without validating; `schema` wins if both are set. Resolves to `null` on
+  failure — filter with `.filter(Boolean)`. Options: `label` (display name),
+  `phase` (progress group — use this inside concurrent stages), `schema`,
   `json`, `model`, `effort` (`'low'` for mechanical stages, higher for the
   hardest verify/judge stages), `allowedTools`, `systemPrompt` (extra system
   prompt for this subagent), `timeoutMs` (default 10 minutes), `maxToolCalls`

package/dist/types/tools/impl/grep-files.d.ts

@@ -1,19 +0,0 @@
-interface GrepFilesArgs {
-    pattern: string;
-    include?: string;
-    path?: string;
-    limit?: number;
-}
-interface GrepFilesResult {
-    output: string;
-    matches?: number;
-    files?: number;
-    truncated?: boolean;
-}
-/**
- * Codex-style grep_files tool.
- * Uses the existing Grep implementation and returns a list of files with matches.
- */
-export declare function grep_files(args: GrepFilesArgs): Promise<GrepFilesResult>;
-export {};
-//# sourceMappingURL=grep-files.d.ts.map

package/dist/types/tools/impl/grep-files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"grep-files.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/grep-files.ts"],"names":[],"mappings":"AAGA,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAID;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CA0C1B"}

package/dist/types/tools/impl/list-dir-codex.d.ts

@@ -1,21 +0,0 @@
-interface ListDirCodexArgs {
-    dir_path: string;
-    offset?: number;
-    limit?: number;
-    depth?: number;
-}
-interface ListDirCodexResult {
-    content: string;
-}
-/**
- * Codex-style list_dir tool.
- * Lists entries with pagination and depth control.
- *
- * Defaults:
- * - offset: 1 (1-indexed)
- * - limit: 25
- * - depth: 2 (immediate children + one nested level)
- */
-export declare function list_dir(args: ListDirCodexArgs): Promise<ListDirCodexResult>;
-export {};
-//# sourceMappingURL=list-dir-codex.d.ts.map

package/dist/types/tools/impl/list-dir-codex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list-dir-codex.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/list-dir-codex.ts"],"names":[],"mappings":"AAYA,UAAU,gBAAgB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,kBAAkB;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAcD;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CAqD7B"}

package/dist/types/tools/impl/multi-edit.d.ts

@@ -1,21 +0,0 @@
-interface Edit {
-    old_string: string;
-    new_string: string;
-    replace_all?: boolean;
-}
-export interface MultiEditArgs {
-    file_path: string;
-    edits: Edit[];
-}
-interface EditWithLine {
-    description: string;
-    startLine: number;
-}
-interface MultiEditResult {
-    message: string;
-    edits_applied: number;
-    edits: EditWithLine[];
-}
-export declare function multi_edit(args: MultiEditArgs): Promise<MultiEditResult>;
-export {};
-//# sourceMappingURL=multi-edit.d.ts.map

package/dist/types/tools/impl/multi-edit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multi-edit.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/multi-edit.ts"],"names":[],"mappings":"AAKA,UAAU,IAAI;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AACD,UAAU,YAAY;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CAoF1B"}

package/dist/types/tools/impl/read-file-codex.d.ts

@@ -1,24 +0,0 @@
-interface IndentationOptions {
-    anchor_line?: number;
-    max_levels?: number;
-    include_siblings?: boolean;
-    include_header?: boolean;
-    max_lines?: number;
-}
-interface ReadFileCodexArgs {
-    file_path: string;
-    offset?: number;
-    limit?: number;
-    mode?: "slice" | "indentation" | string;
-    indentation?: IndentationOptions;
-}
-interface ReadFileCodexResult {
-    content: string;
-}
-/**
- * Codex-style read_file tool.
- * Supports both slice mode (simple range) and indentation mode (context-aware block reading).
- */
-export declare function read_file(args: ReadFileCodexArgs): Promise<ReadFileCodexResult>;
-export {};
-//# sourceMappingURL=read-file-codex.d.ts.map

package/dist/types/tools/impl/read-file-codex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-file-codex.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/read-file-codex.ts"],"names":[],"mappings":"AAOA,UAAU,kBAAkB;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,GAAG,aAAa,GAAG,MAAM,CAAC;IACxC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AASD;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAiC9B"}

package/dist/types/tools/impl/shell-command.d.ts

@@ -1,25 +0,0 @@
-interface ShellCommandArgs {
-    command: string;
-    description?: string;
-    workdir?: string;
-    login?: boolean;
-    timeout_ms?: number;
-    sandbox_permissions?: "use_default" | "require_escalated";
-    justification?: string;
-    prefix_rule?: string[];
-    signal?: AbortSignal;
-    onOutput?: (chunk: string, stream: "stdout" | "stderr") => void;
-    secretEnv?: Record<string, string>;
-}
-interface ShellCommandResult {
-    output: string;
-    stdout?: string[];
-    stderr?: string[];
-}
-/**
- * Codex-style shell_command tool.
- * Runs a shell script string in the user's default shell.
- */
-export declare function shell_command(args: ShellCommandArgs): Promise<ShellCommandResult>;
-export {};
-//# sourceMappingURL=shell-command.d.ts.map

package/dist/types/tools/impl/shell-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shell-command.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/shell-command.ts"],"names":[],"mappings":"AASA,UAAU,gBAAgB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,aAAa,GAAG,mBAAmB,CAAC;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,UAAU,kBAAkB;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD;;;GAGG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CAwD7B"}

package/dist/types/tools/impl/shell.d.ts

@@ -1,25 +0,0 @@
-interface ShellArgs {
-    command: string[];
-    workdir?: string;
-    timeout_ms?: number;
-    env_overrides?: NodeJS.ProcessEnv;
-    secretEnv?: Record<string, string>;
-    with_escalated_permissions?: boolean;
-    justification?: string;
-    signal?: AbortSignal;
-    onOutput?: (chunk: string, stream: "stdout" | "stderr") => void;
-}
-export declare function resolveShellWorkdir(workdir?: string): string;
-export interface ShellResult {
-    output: string;
-    stdout: string[];
-    stderr: string[];
-}
-/**
- * Codex-style shell tool.
- * Runs an array of shell arguments using execvp-style semantics.
- * Typically called with ["bash", "-lc", "..."] for shell commands.
- */
-export declare function shell(args: ShellArgs): Promise<ShellResult>;
-export {};
-//# sourceMappingURL=shell.d.ts.map

package/dist/types/tools/impl/shell.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/shell.ts"],"names":[],"mappings":"AAaA,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC;CACjE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAS5D;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AA8DD;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CA8EjE"}

package/dist/types/tools/impl/todo-write.d.ts

@@ -1,14 +0,0 @@
-interface TodoItem {
-    content: string;
-    status: "pending" | "in_progress" | "completed";
-    activeForm: string;
-}
-interface TodoWriteArgs {
-    todos: TodoItem[];
-}
-interface TodoWriteResult {
-    message: string;
-}
-export declare function todo_write(args: TodoWriteArgs): Promise<TodoWriteResult>;
-export {};
-//# sourceMappingURL=todo-write.d.ts.map

package/dist/types/tools/impl/todo-write.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"todo-write.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/todo-write.ts"],"names":[],"mappings":"AAEA,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB;AACD,UAAU,aAAa;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AACD,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CAqB1B"}