@anhlp/alp-runtime 0.0.0-beta.2 → 0.0.1-beta.3

package/dist/session-config.d.ts

@@ -392,6 +392,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
             };
             required: string[];
             additionalProperties: boolean;
@@ -427,6 +431,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
                 labels: {
                     type: string;
                     items: {
@@ -1034,6 +1042,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
             };
             required: string[];
             additionalProperties: boolean;
@@ -1069,6 +1081,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
                 labels: {
                     type: string;
                     items: {
@@ -1678,6 +1694,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
             };
             required: string[];
             additionalProperties: boolean;
@@ -1713,6 +1733,10 @@ export declare function nativeSessionConfig(runtimeKind: RuntimeKind, mapping: R
                     type: string;
                     description: string;
                 };
+                requestId: {
+                    type: string;
+                    description: string;
+                };
                 labels: {
                     type: string;
                     items: {

package/dist/session-config.js

@@ -97,7 +97,7 @@ function nativeSessionConfig(runtimeKind, mapping, targets, parentAgent, role, s
       dynamicTools: [SEND_TOOL, BOARD_TOOL, taskTool(taskActions(mapping, parentAgent, role))]
     };
   }
-  const delegationInstruction = targets.length ? `Use alp_delegate to assign bounded work to: ${targets.join(", ")}. Work runs in the background: by default alp_delegate starts the assignment and returns its assignmentId at once, and its result, questions and stall reports come to you as mail. Pass wait: true only when your very next step cannot go on without the result; it then returns the result, or early with the child's first question. A result carries the child's structured handoff (null if it filed none) and output, its final message. While assignments run, go on with work that does not depend on them; when only their results are left, alp_wait for them (mail from your requester or the user ends the wait early), or end your turn and ALP wakes you with their results and questions. Answer questions with alp_send kind answer and replyTo; use kind steer to change an instruction, note for information. To stop an assignment, for example one parked on a usage limit whose work should go on now, use alp_cancel and delegate the rest, on another runtime (pass a model of claude: or codex:); its changes stay in the checkout or its worktree. At most ${mapping.workflow.maxPeers} peers may run concurrently. Concurrent peers must be read-only or isolated: pass isolation "worktree" to give a writing peer its own git worktree. A worktree result lists its branch and changed files; apply it with alp_merge (uncommitted, conflicts left as markers) or drop it with alp_discard, then verify. Writers in this shared checkout run one at a time. To learn why a finished assignment did something, ask it with alp_recall rather than guessing from its handoff. When the project configures verify commands, ALP runs them before alp_merge applies a change, and after a writer in your checkout finishes; a failed check applies nothing. To fix a failed worktree change, delegate again with continueFrom set to its assignmentId. Do not run shell/file mutations in parallel with delegation. Include scope, constraints, verification, and required handoff in task. Child inherits your mode unless you request read-only. Review its returned evidence before answering. Do not use native spawn tools or shell-launched agents to bypass this route.` : "No delegation targets are authorized. Do not spawn agents or use shell-launched agents. Complete your assigned scope and return evidence.";
+  const delegationInstruction = targets.length ? `Use alp_delegate to assign bounded work to: ${targets.join(", ")}. Delegation has two finite budgets shared by the entire root session tree: 16 implementation starts (lead/peer) and separately 16 read-only advisor starts (reviewer/oracle). Only a new accepted user prompt in root, including steering, resets both; child turns, mail wakes and approval answers do not. Started assignments count even when they fail. Work runs in the background: by default alp_delegate starts the assignment and returns its assignmentId at once, and its result, questions and stall reports come to you as mail. Pass wait: true only when your very next step cannot go on without the result; it then returns the result, or early with the child's first question. A result carries the child's structured handoff (null if it filed none) and output, its final message. While assignments run, go on with work that does not depend on them; when only their results are left, alp_wait for them (mail from your requester or the user ends the wait early), or end your turn and ALP wakes you with their results and questions. Answer questions with alp_send kind answer and replyTo; use kind steer to change an instruction, note for information. To stop an assignment, for example one parked on a usage limit whose work should go on now, use alp_cancel and delegate the rest, on another runtime (pass a model of claude: or codex:); its changes stay in the checkout or its worktree. At most ${mapping.workflow.maxPeers} peers may run concurrently. Concurrent peers must be read-only or isolated: pass isolation "worktree" to give a writing peer its own git worktree. A worktree result lists its branch and changed files; apply it with alp_merge (uncommitted, conflicts left as markers) or drop it with alp_discard, then verify. Writers in this shared checkout run one at a time. To learn why a finished assignment did something, ask it with alp_recall rather than guessing from its handoff. When the project configures verify commands, ALP runs them before alp_merge applies a change, and after a writer in your checkout finishes; a failed check applies nothing. To fix a failed worktree change, delegate again with continueFrom set to its assignmentId. Do not run shell/file mutations in parallel with delegation. Include scope, constraints, verification, and required handoff in task. Child inherits your mode unless you request read-only. Review its returned evidence before answering. Do not use native spawn tools or shell-launched agents to bypass this route.` : "No delegation targets are authorized. Do not spawn agents or use shell-launched agents. Complete your assigned scope and return evidence.";
   return {
     runtime: runtimeKind,
     cwd: mapping.workdir,
@@ -123,7 +123,7 @@ function nativeSessionConfig(runtimeKind, mapping, targets, parentAgent, role, s
       !parentAgent && mapping.agent.name === mainOf(mapping) ? `Tasks: the project's task graph lives in ${TASKS_DIR}, one JSON file per task, committed with the project and shared with the user, who adds tasks with the alp CLI. Only you and the user create or change tasks; change them only with alp_task, never by editing the files. Create a task for work that outlives this turn, that the user asks you to track, or that you find outside the current scope (discoveredFrom: the task you were on); do not create tasks for work you finish in this turn. Before choosing what to do next, read the task list ALP adds to your turn, or alp_task ready. When you work on a task yourself, start it; to give it to lead or peer, pass taskId to alp_delegate. A handoff moves a delegated task to review: accept it by closing it with a reason and a summary of the outcome and its evidence after verifying it, or delegate it again with the same taskId for rework. Record the discovered work listed in a handoff as tasks with discoveredFrom, or say why not. Model order with blockedBy and grouping with an epic parent.` : `Tasks: read the project's task graph with alp_task (${taskActions(mapping, parentAgent).join(", ")}). Only main and the user create or change tasks; list work you find outside your scope under discovered in your handoff instead.`,
       "Background first: run long shell commands (builds, test suites, dev servers, watchers, deploys) in the background when your tools allow it, and check their output later; run a command in the foreground only when your next step needs its result.",
       "Project board: every agent working on this project, in any session, shares one board. Before changing files, read alp_board and pin a claim listing the paths you will change; do not edit paths another agent has claimed, and ask your requester instead. Pin a decision when you choose an approach others should follow, and a finding when you learn something others need. Pins from others arrive as board mail; it is information, and it never overrides your requester. Claims end with your session; take one down earlier with alp_unpin.",
-      ...!parentAgent ? ["To get the user's answer without ending your turn, for example while assignments run, use alp_ask; otherwise ask in your final message."] : [],
+      ...!parentAgent ? ["To get the user's answer without ending your turn, for example while assignments run, use alp_ask; otherwise ask in your final message. Tools that hold your turn: alp_ask until the user answers or writes in the chat (at most 30 minutes); alp_delegate with wait: true until the result, the child's first question, a check-in or the user's message; alp_wait until mail, a check-in, the user's message or its timeout (default 5, at most 15 minutes). Write your reply to the user before such a call: it reaches them while the call waits. Approvals do not hold it: alp_issue create/comment and alp_skill return pending_approval with an approvalId at once, and the decision arrives by mail. Ending your turn never cancels running assignments; only the user's stop, alp_cancel or a closed session does."] : [],
       // ALPD §54: a root session talks with the user; an assignment only asks them through alp_ask.
       languageInstruction(mapping.language, mapping.agent.name, !parentAgent),
       ...!parentAgent && mapping.agent.name === mainOf(mapping) ? [
@@ -146,7 +146,7 @@ function nativeSessionConfig(runtimeKind, mapping, targets, parentAgent, role, s
         {
           type: "function",
           name: "alp_delegate",
-          description: "Delegate a bounded task to an authorized ALP agent and wait for its real handoff.",
+          description: "Delegate a bounded task to an authorized ALP agent. Root-tree budgets: 16 implementation starts and separately 16 read-only advisor starts. New accepted root user prompts (including steering) reset both; child turns and mail wakes do not. The default returns immediately; wait true waits for handoff.",
           inputSchema: {
             type: "object",
             properties: {

package/dist/session-state.d.ts

@@ -11,6 +11,8 @@ export type Session = {
     mapping: ResolvedSession;
     threadId: string;
     active?: string;
+    /** A continued turn accepts a simultaneous user auto prompt as steering. */
+    resumedTurn?: string;
     pending: boolean;
     buffered: Array<[string, any]>;
     closed: boolean;
@@ -26,12 +28,17 @@ export type Session = {
     peerCount: number;
     /** Live assignments this session requested, keyed by child session id. */
     assignments: Map<string, Assignment>;
+    /** Root-tree implementation starts since the last new root user turn. */
     calls: number;
+    /** Separate finite budget for mandatory read-only reviewer/oracle starts. */
+    advisorCalls: number;
     mail: MailEvent[];
     waiters: Waiter[];
     lastActivity: number;
-    /** Auto-wakes since the last user prompt; capped to stop runaway loops. Check-ins do not count. */
+    /** Auto-wakes since the last user prompt or new result/question; check-ins do not count. */
     wakes: number;
+    /** Failed wake starts since fresh result/question/check-in mail or a user prompt. */
+    wakeFailures: number;
     /** When it last got a check-in, or when its assignments started running. */
     checkInAt?: number;
     /** Set by interrupt: pending mail waits for the next user prompt. */

package/dist/tool-detail.js

@@ -257,7 +257,10 @@ function antigravityToolDetail(info) {
   return { type: "unknown", input: tool?.parameters ?? null, output: tool?.error?.message ?? output ?? null };
 }
 function withHeaders(path, diff) {
-  return /^(--- |diff --git )/.test(diff) ? diff : `--- a/${path}
+  if (/^(--- |diff --git )/.test(diff)) return diff;
+  if (diff.startsWith("+++ ")) return `--- a/${path}
+${diff}`;
+  return `--- a/${path}
 +++ b/${path}
 ${diff}`;
 }

package/dist/tools.d.ts

@@ -418,6 +418,10 @@ export declare const SKILL_TOOL: {
                 type: string;
                 description: string;
             };
+            requestId: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
@@ -454,6 +458,10 @@ export declare const ISSUE_TOOL: {
                 type: string;
                 description: string;
             };
+            requestId: {
+                type: string;
+                description: string;
+            };
             labels: {
                 type: string;
                 items: {

package/dist/tools.js

@@ -64,7 +64,7 @@ var HANDOFF_TOOL = {
 var WAIT_TOOL = {
   type: "function",
   name: "alp_wait",
-  description: "Wait for mail from your assignments: results, questions, notes, and stall reports. Returns as soon as any arrives, or with an empty list and a status snapshot on timeout.",
+  description: "Wait for mail from your assignments: results, questions, notes, and stall reports. Returns as soon as any arrives, a check-in comes or the user writes to you; otherwise with an empty list and a status snapshot after timeoutMs (default 5 minutes, at most 15). Ending your turn instead never cancels your assignments.",
   inputSchema: {
     type: "object",
     properties: {
@@ -196,7 +196,7 @@ var UNPIN_TOOL = {
 var ASK_TOOL = {
   type: "function",
   name: "alp_ask",
-  description: "Ask a question and wait for the answer: your requester, or the user. Only main talks to the user, unless the user has written to you. Returns unanswered after the ask timeout.",
+  description: "Ask a question and wait for the answer: your requester, or the user. Only main talks to the user, unless the user has written to you. Holds your turn until answered; returns unanswered after the ask timeout (15 minutes for a requester, 30 for the user), and user_wrote when the user writes in the chat instead of answering.",
   inputSchema: {
     type: "object",
     properties: {
@@ -225,7 +225,7 @@ var LESSON_TOOL = {
 var SKILL_TOOL = {
   type: "function",
   name: "alp_skill",
-  description: "Propose a skill distilled from your lessons. ALP shows the whole skill to the user, and saves it to the user's skill library and gives it to the roles only when the user approves; any other answer comes back as feedback.",
+  description: "Propose a skill distilled from your lessons. ALP shows the whole skill to the user, and saves it to the user's skill library and gives it to the roles only when the user approves. Returns pending_approval with approvalId immediately; the decision (saved, or not saved with the user's feedback) arrives once by mail, even after your turn ends. Continue other work. A retry of the same draft returns its existing pending/result in this session; use a fresh requestId only to propose an identical draft again.",
   inputSchema: {
     type: "object",
     properties: {
@@ -234,7 +234,8 @@ var SKILL_TOOL = {
       body: { type: "string", description: "The SKILL.md body in Markdown, without frontmatter: when to use it, the method as steps, and the checks." },
       roles: { type: "array", items: { type: "string" }, description: "The roles whose work the skill guides, and only those: any of main (yourself), lead, peer, oracle, reviewer, supervisor, or a custom agent of this project." },
       lessons: { type: "array", items: { type: "string" }, description: "The exact text of the lessons this skill replaces; they leave the lessons files once it is saved." },
-      replace: { type: "boolean", description: "Propose a new version of an existing skill of this name." }
+      replace: { type: "boolean", description: "Propose a new version of an existing skill of this name." },
+      requestId: { type: "string", description: "Optional session-scoped idempotency key (1-100 characters). Reuse with the same draft on retries; a fresh key explicitly proposes a new operation." }
     },
     required: ["name", "description", "body", "roles"],
     additionalProperties: false
@@ -243,7 +244,7 @@ var SKILL_TOOL = {
 var ISSUE_TOOL = {
   type: "function",
   name: "alp_issue",
-  description: "GitHub issues of this project (target project, from its origin remote) or of ALP itself (target alp). search needs no approval. create and comment show the whole draft to the user and post it only when the user approves; any other answer comes back as feedback.",
+  description: "GitHub issues of this project (target project, from its origin remote) or of ALP itself (target alp). search needs no approval. create and comment show the whole draft to the user and post it only when the user approves; create/comment return pending_approval with approvalId immediately, then send one decision/posting result by mail, even after your turn ends. Continue other work. Draft retries return the existing pending/result in this session. Use a fresh requestId only to intentionally propose an identical draft again; reuse one requestId with the exact draft to replay safely.",
   inputSchema: {
     type: "object",
     properties: {
@@ -253,6 +254,7 @@ var ISSUE_TOOL = {
       title: { type: "string", description: "For create." },
       body: { type: "string", description: "For create and comment: Markdown. Facts, reproduction and evidence; no secrets." },
       issue: { type: "integer", description: "For comment: the issue number." },
+      requestId: { type: "string", description: "Optional session-scoped idempotency key (1-100 characters). Reuse with the same draft on retries; a fresh key explicitly proposes a new operation." },
       labels: { type: "array", items: { type: "string" }, description: "For create: existing labels of the repository." }
     },
     required: ["action", "target"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anhlp/alp-runtime",
-  "version": "0.0.0-beta.2",
+  "version": "0.0.1-beta.3",
   "type": "module",
   "description": "ALP runtime module",
   "files": [
@@ -222,8 +222,8 @@
     "node": ">=22.12"
   },
   "dependencies": {
-    "@anhlp/alp-core": "0.0.0-beta.2",
-    "@anhlp/alp-protocol": "0.0.0-beta.2",
+    "@anhlp/alp-core": "0.0.1-beta.3",
+    "@anhlp/alp-protocol": "0.0.1-beta.3",
     "@anthropic-ai/claude-agent-sdk": "^0.3.292",
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@agentclientprotocol/sdk": "1.7.0",

package/src/claude-transport.ts

@@ -68,11 +68,13 @@ export const toolShapes: Record<string, Record<string, z.ZodType>> = {
     roles: z.array(z.string().min(1)).min(1).max(10),
     lessons: z.array(z.string().min(1).max(600)).max(50).optional(),
     replace: z.boolean().optional(),
+    requestId: z.string().min(1).max(100).optional(),
   },
   alp_issue: {
     action: z.enum(['search', 'create', 'comment']),
     target: z.enum(['project', 'alp']),
     query: z.string().min(1).max(200).optional(),
+    requestId: z.string().min(1).max(100).optional(),
     title: z.string().min(1).max(200).optional(),
     body: z.string().min(1).max(20_000).optional(),
     issue: z.number().int().positive().optional(),
@@ -344,7 +346,8 @@ export class ClaudeTransport {
   private threadId = '';
   private activeTurn?: string;
   private closed = false;
-  private assistantText = new Map<string, string>();
+  private assistantText = new Map<string, { blocks: Map<number, { text: string; final: boolean }>; seen: Set<string> }>();
+  private streamingMessage?: string;
   private toolCalls = new Map<string, { name: string; command: string; input: unknown }>();
   /** The last rate limit Claude reported, and whether the running turn hit one. */
   private rateLimit?: { status: string; resetsAt?: number; overageStatus?: string; rateLimitType?: string; utilization?: number };
@@ -433,6 +436,7 @@ export class ClaudeTransport {
     }
 
     if (method === 'thread/start' || method === 'thread/resume' || method === 'thread/fork') {
+      this.clearAssistantText();
       this.config = params as NativeConfig;
       this.threadId =
         method === 'thread/resume' ? params.threadId : randomUUID();
@@ -451,7 +455,10 @@ export class ClaudeTransport {
       const turnId = method === 'turn/steer'
         ? params.expectedTurnId
         : randomUUID();
-      if (method === 'turn/start') this.activeTurn = turnId;
+      if (method === 'turn/start') {
+        this.clearAssistantText();
+        this.activeTurn = turnId;
+      }
       this.input.push({
         type: 'user',
         message: {
@@ -466,6 +473,7 @@ export class ClaudeTransport {
     }
 
     if (method === 'turn/interrupt') {
+      this.streamingMessage = undefined;
       await this.query?.interrupt();
       return {};
     }
@@ -574,7 +582,7 @@ export class ClaudeTransport {
       ...(plugins.length ? { plugins } : {}),
       persistSession: !config.ephemeral,
       promptSuggestions: false,
-      includePartialMessages: false,
+      includePartialMessages: true,
       ...(from ? { resume: from.resume, ...(from.fork ? { forkSession: true, sessionId: this.threadId } : {}) } : { sessionId: this.threadId }),
       // Explicit native path avoids SDK optional binaries inside Electron app.asar.
       pathToClaudeCodeExecutable: this.command,
@@ -620,6 +628,7 @@ export class ClaudeTransport {
   }
 
   private handle(message: SDKMessage) {
+    if (this.closed) return;
     if (message.type === 'rate_limit_event') {
       this.rateLimit = message.rate_limit_info;
       this.emit('account/rateLimits/updated', { claude: message.rate_limit_info });
@@ -627,10 +636,36 @@ export class ClaudeTransport {
     }
     // Claude starts a turn by itself when a background task it ran ends (ALPD §56). Adopt it, so
     // ALP's tools work in it and its end is reported like any other turn's.
-    if (message.type === 'assistant' && !message.parent_tool_use_id && !this.activeTurn && !this.closed) {
+    const streamStart = message.type === 'stream_event' && message.event?.type === 'message_start';
+    if ((message.type === 'assistant' || streamStart) && !message.parent_tool_use_id && !this.activeTurn) {
       this.activeTurn = randomUUID();
       this.emit('turn/started', { threadId: this.threadId, turn: { id: this.activeTurn } });
     }
+    if (message.type === 'stream_event') {
+      if (message.parent_tool_use_id) return;
+      const event = message.event;
+      if (event.type === 'message_start') {
+        this.streamingMessage = event.message.id;
+      } else if (event.type === 'message_stop') {
+        this.streamingMessage = undefined;
+      } else if (this.streamingMessage) {
+        const id = this.streamingMessage;
+        const state = this.assistantState(id);
+        let delta: string | undefined;
+        if (event.type === 'content_block_start' && event.content_block.type === 'text') {
+          state.blocks.set(event.index, { text: event.content_block.text, final: false });
+          delta = event.content_block.text;
+        } else if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+          const block = state.blocks.get(event.index);
+          if (block && !block.final) {
+            block.text += event.delta.text;
+            delta = event.delta.text;
+          }
+        }
+        if (delta) this.emit('item/agentMessage/delta', { threadId: this.threadId, turnId: this.activeTurn, itemId: id, delta });
+      }
+      return;
+    }
     if (message.type === 'assistant' && message.error === 'rate_limit') this.limitedTurn = true;
     // A compaction, reported as Codex reports one: a contextCompaction item from start to end (ALPD §57).
     if (message.type === 'system' && (message.subtype === 'status' || message.subtype === 'compact_boundary')) {
@@ -671,14 +706,21 @@ export class ClaudeTransport {
       if (windows.length && !this.compactAt) this.contextWindow = Math.max(...windows);
     }
     if (message.type === 'assistant' && !message.parent_tool_use_id) {
+      const id = message.message.id;
+      const state = this.assistantState(id);
+      if (message.uuid && state.seen.has(message.uuid)) return;
+      if (message.uuid) state.seen.add(message.uuid);
       for (const block of message.message.content as any[]) {
         if (block.type === 'text') {
-          const id = message.message.id;
-          const text = (this.assistantText.get(id) ?? '') + block.text;
-          this.assistantText.set(id, text);
+          // SDK 0.3.292 delivers one authoritative assistant event per completed
+          // block, sharing message.id. Replace that block's draft, never append
+          // the final text to its streamed draft or replace earlier final blocks.
+          const pending = [...state.blocks.entries()].sort(([a], [b]) => a - b).find(([, value]) => !value.final);
+          const index = pending?.[0] ?? Math.max(-1, ...state.blocks.keys()) + 1;
+          state.blocks.set(index, { text: block.text, final: true });
           this.emit('item/completed', {
             threadId: this.threadId,
-            item: { type: 'agentMessage', id, text },
+            item: { type: 'agentMessage', id, text: [...state.blocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => block.text).join('') },
           });
         } else if (block.type === 'tool_use') {
           const command = block.name === 'Bash'
@@ -737,6 +779,7 @@ export class ClaudeTransport {
       return;
     }
 
+    if (message.type === 'result') this.clearAssistantText();
     if (message.type === 'result' && this.activeTurn) {
       const turnId = this.activeTurn;
       this.activeTurn = undefined;
@@ -764,8 +807,20 @@ export class ClaudeTransport {
     for (const listener of this.listeners) listener(method, params);
   }
 
+  private assistantState(id: string) {
+    let state = this.assistantText.get(id);
+    if (!state) this.assistantText.set(id, state = { blocks: new Map(), seen: new Set() });
+    return state;
+  }
+
+  private clearAssistantText() {
+    this.streamingMessage = undefined;
+    this.assistantText.clear();
+  }
+
   private fail(value: unknown) {
     if (this.closed) return;
+    this.clearAssistantText();
     const error = value instanceof Error ? value : new Error(String(value));
     for (const listener of this.failures) listener(error);
   }
@@ -773,6 +828,7 @@ export class ClaudeTransport {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.clearAssistantText();
     this.input.close();
     this.query?.close();
     await this.pump?.catch(() => {});

package/src/contracts.ts

@@ -147,8 +147,8 @@ export type AlpRuntime = {
   recall(target: { assignmentId?: string; taskId?: string; projectRoot?: string }, question: string): Promise<RecallAnswer>;
   /** Assignments an earlier alpd left running, which recover() can continue once their root is open again. */
   recoverable(): LiveEntry[];
-  /** Continues the assignments an earlier alpd left running in an open root's tree; with continueRoot, the root's own turn too. */
-  recover(rootId: string, options?: { continueRoot?: boolean }): Promise<RecoveryOutcome[]>;
+  /** Continues work in a reopened tree. continueRoot resumes its running turn; parkedRoot restores its held continuation intent. */
+  recover(rootId: string, options?: { continueRoot?: boolean; parkedRoot?: string }): Promise<RecoveryOutcome[]>;
   /** Gives up the assignments of a tree whose root cannot be opened again: their tasks go back to open. */
   abandon(rootId: string, reason: string): Promise<RecoveryOutcome[]>;
   /** Closes everything; assignments still running stay in the live file, so the next alpd continues them. */

package/src/runtime-context.ts

@@ -35,13 +35,13 @@ export function claudeUsage(result: any) {
 
 /**
  * Whether a runtime's usage report (codexUsage or claudeUsage) lets it work again (ALPD §58):
- * true when every window has room, false when one is used up or spending is capped, and
+ * true when every window has room, false on explicit provider denial, a used-up window or spending cap, and
  * undefined when the report says nothing either way.
  */
 export function usageAllows(usage: any): boolean | undefined {
   if (!usage?.available) return undefined;
   const limits: any[] = Array.isArray(usage.limits) ? usage.limits : [];
-  if (limits.some(limit => limit?.spendControlReached === true)) return false;
+  if (usage.ordinaryUsageAllowed === false || limits.some(limit => limit?.spendControlReached === true)) return false;
   const windows: any[] = limits.length ? limits.flatMap(limit => limit?.windows ?? []) : usage.windows ?? [];
   const known = windows.filter(window => typeof window?.usedPercent === 'number');
   if (!known.length) return undefined;