@letta-ai/letta-code 0.33.3 → 0.33.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.33.3",
+  "version": "0.33.5",
   "lettaStartupLogProtocol": 1,
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
@@ -132,7 +132,7 @@
   "dependencies": {
     "@earendil-works/pi-ai": "^0.87.1",
     "@janhapke/sharp-electron": "0.35.3-electron.1",
-    "@letta-ai/letta-agent-sdk": "^0.8.17",
+    "@letta-ai/letta-agent-sdk": "0.8.21",
     "@letta-ai/letta-client": "^1.10.2",
     "@letta-ai/trajectory": "0.2.0",
     "@modelcontextprotocol/sdk": "1.30.0",

package/scripts/source-file-size-baseline.json

@@ -35,11 +35,10 @@
   "src/settings-manager.ts": 2101,
   "src/tools/manager.ts": 2649,
   "src/tools/tool-execution-context.test.ts": 1092,
-  "src/types/protocol_v2.ts": 2574,
-  "src/websocket/listen-client-concurrency.test.ts": 2666,
+  "src/types/protocol_v2.ts": 2550,
+  "src/websocket/listen-client-concurrency.test.ts": 2663,
   "src/websocket/listen-client-protocol.test.ts": 5759,
   "src/websocket/listener/commands/memory.ts": 1114,
   "src/websocket/listener/file-commands.ts": 1053,
-  "src/websocket/listener/protocol-inbound.ts": 2111,
-  "src/websocket/listener/protocol-outbound.ts": 1022
+  "src/websocket/listener/protocol-inbound.ts": 2111
 }

package/skills/workflow-authoring/SKILL.md

@@ -78,7 +78,8 @@ Workflow subagents require the API backend.
   `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`
-  (positive safe integer; default 1000 unique tool calls for this subagent).
+  (positive safe integer; default 1000 unique tool calls for this subagent),
+  `conversationId` (resume a worker — see "Diagnosing a run").
 - `pipeline(items, stage1, stage2, ...)` → run each item through all stages
   independently, NO barrier between stages. Item A can be in stage 3 while
   item B is still in stage 1. This is the DEFAULT for multi-stage work.
@@ -95,9 +96,30 @@ Workflow subagents require the API backend.
 - `phase(title)` — start a new phase; subsequent agent() calls are grouped
   under this title in progress output.
 - `log(message)` — emit a progress message to the user.
+- `decide(state, questions, opts?)` → Promise; not a subagent call. Ask a
+  calibrated Jev model (chosen internally — no model option) questions about
+  `state`. `questions` is a non-empty OBJECT keyed by question id — never an
+  array. Each question needs `instructions` and a `type`: `choice` (criteria
+  map of id → description, ≤255), `score` (criteria array of strings, unlike
+  `questions`), `noul` (no criteria). Returns a response whose `answers` are
+  keyed by the same ids and calibrated, or `null` after one retried invalid
+  answer — guard `if (!call)`; API errors throw.
+
+      const call = await decide(evidence, {
+        behavior: { type: 'choice', instructions: 'Is this behavior a bug?',
+          criteria: { bad: 'Wrong or harmful', not_bad: 'Expected or harmless' } },
+      })
+      const verdict = call?.answers?.behavior?.choice  // 'bad' | 'not_bad'
+
 - `args` — the value passed as the tool's `args` input, verbatim. Pass
   arrays/objects as actual JSON values, NOT as a JSON-encoded string.
 
+`decide()` sees only the `state` you pass; it cannot read files. When compact,
+bounded items are already prepared, pass them via `args` and call `decide()`
+on each directly — don't spawn `agent()` readers just to relay inputs. Raw
+large traces don't belong in `args`: prepare bounded state that preserves the
+user instruction, observed action, and outcome, and mark what was omitted.
+
 Scripts are plain JavaScript, NOT TypeScript — type annotations, interfaces,
 and generics fail to parse. The script body runs in an async context — use
 `await` directly and `return` the final result. Standard JS built-ins (JSON,
@@ -125,9 +147,9 @@ A barrier is NOT justified by:
   slowest takes 3× the fastest, a barrier wastes 2/3 of the fast finders'
   idle time.
 
-Concurrent agent() calls are capped per run (`maxConcurrent`, default 16) —
-excess calls queue and run as slots free up, so passing 100 items is fine.
-Total agent count across a run is capped at 1000 — a runaway-loop backstop.
+`agent()` and `decide()` share one pool of concurrent slots per run
+(`maxConcurrent`, default 16) — excess calls queue and run as slots free up,
+so passing 100 items is fine. Each has its own 1000-call lifetime backstop.
 A single parallel()/pipeline() call accepts at most 4096 items.
 
 When a barrier IS correct — dedup across all findings before expensive
@@ -216,3 +238,8 @@ diagnosing why a workflow returned an empty or unexpected result, read that
 journal — it records each agent's actual return value and, for a `null`,
 which guard or error produced it. A failed run is not resumable: fix the
 script and launch it again.
+
+The script is never replayed, but one worker can continue:
+`agent(prompt, {conversationId})` re-prompts it with history and model intact,
+using a journal ID and only once its last Run is terminal. Tools default to
+`[]`; `schema` and `effort` are chosen per turn. Needs SDK 0.8.20+.