jeo-code 0.8.41 → 0.8.43

package/src/agent/monitor-tool.ts

@@ -0,0 +1,51 @@
+import type { ToolHandler } from "./engine";
+import type { ToolResult } from "./tools";
+import type { JobRegistry, MonitorCategory } from "./job-registry";
+
+/** One-line protocol description appended to the launch system prompt. */
+export const MONITOR_TOOL_PROTOCOL_LINE =
+  "monitor {command, kind, description, timeout?, persistent?} starts a turn-scoped stdout monitor. " +
+  "Each newline-terminated stdout line is a notification; non-persistent monitors stop after the first line. " +
+  "Use job {action:\"list\"|\"tail\"|\"await\"|\"cancel\", ids?} with its returned job id to inspect or cancel it.";
+
+const MONITOR_CATEGORIES: readonly MonitorCategory[] = ["log", "poll", "watch", "other"];
+
+export function createMonitorTool(registry: JobRegistry): ToolHandler {
+  return async (args: Record<string, any>, cwd: string): Promise<ToolResult> => {
+    const command = typeof args.command === "string" ? args.command.trim() : "";
+    if (!command) {
+      return { success: false, output: "", error: "monitor requires a non-empty 'command'." };
+    }
+
+    const description = typeof args.description === "string" ? args.description.trim() : "";
+    if (!description) {
+      return { success: false, output: "", error: "monitor requires a non-empty 'description'." };
+    }
+
+    const kind = args.kind;
+    if (typeof kind !== "string" || !MONITOR_CATEGORIES.includes(kind as MonitorCategory)) {
+      return { success: false, output: "", error: "monitor requires 'kind' to be exactly log, poll, watch, or other." };
+    }
+
+    if (args.timeout !== undefined && (typeof args.timeout !== "number" || !Number.isFinite(args.timeout) || args.timeout <= 0)) {
+      return { success: false, output: "", error: "monitor 'timeout' must be a finite positive number of seconds." };
+    }
+
+    if (args.persistent !== undefined && typeof args.persistent !== "boolean") {
+      return { success: false, output: "", error: "monitor 'persistent' must be a boolean." };
+    }
+
+    const resolvedCwd = typeof args.cwd === "string" && args.cwd.trim() ? args.cwd : cwd;
+    const record = registry.startMonitor(command, resolvedCwd, {
+      category: kind as MonitorCategory,
+      description,
+      persistent: args.persistent ?? false,
+      timeout: args.timeout,
+    });
+    return {
+      success: true,
+      output: `[monitor] started '${record.id}' (persistent: ${record.persistent}). ` +
+        "Use the job tool to inspect, await, or cancel it.",
+    };
+  };
+}

package/src/agent/subagent-registry.ts

@@ -11,8 +11,8 @@
  * can push a message into a running detached subagent's inbox; the subagent's own
  * agent loop drains it between steps, same mechanism as ordinary task steering.
  *
- * Lifecycle is bounded to the turn that created the registry — `cancelAll()` on
- * turn teardown guarantees no background promise leaks into the next turn.
+ * Lifecycle is bounded to the originating turn: `cancelAll()` requests cooperative
+ * abort on teardown. A filesystem operation already committing cannot be rolled back.
  */
 import type { ToolResult } from "./tools";
 

package/src/agent/subagent-tool.ts

@@ -75,7 +75,7 @@ export function createSubagentTool(registry: SubagentRegistry): ToolHandler {
       const head = stillRunning > 0
         ? `Awaited ${recs.length} subagent(s); ${stillRunning} still running after the ${timeoutMs}ms timeout — await again or cancel.`
         : `Awaited ${recs.length} subagent(s); all settled.`;
-      return { success: stillRunning === 0, output: `${head}\n\n${recs.map(detailBlock).join("\n\n")}` };
+      return { success: true, output: `${head}\n\n${recs.map(detailBlock).join("\n\n")}` };
     }
 
     if (action === "cancel") {

package/src/agent/subagents.ts

@@ -302,7 +302,7 @@ export function subagentToolset(role: SubagentRole): Record<string, ToolHandler>
   if (prefixes && prefixes.length > 0) {
     const inner = DEFAULT_TOOLS.bash;
     const guarded: Record<string, ToolHandler> = { ...DEFAULT_TOOLS };
-    guarded.bash = async (a, cwd) => {
+    guarded.bash = async (a, cwd, onProgress, signal) => {
       const command = String(a.command ?? a.cmd ?? "");
       if (!bashCommandAllowed(command, prefixes)) {
         return {
@@ -313,7 +313,7 @@ export function subagentToolset(role: SubagentRole): Record<string, ToolHandler>
             `Received: ${command.trim().slice(0, 120)}`,
         };
       }
-      return inner(a, cwd);
+      return inner(a, cwd, onProgress, signal);
     };
     return guarded;
   }

package/src/agent/task-tool.ts

@@ -52,6 +52,10 @@ export type SubagentTaskConfig = RoutingConfig & Pick<Config, "subagents" | "thi
 /** Lifecycle event emitted while a delegated subagent runs. */
 export interface TaskSubEvent {
   role: string;
+  /** Stable registry id for a detached run; absent for synchronous work. */
+  id?: string;
+  /** True when this event belongs to a detached registry run. */
+  detached?: boolean;
   /** `"thinking"` streams the subagent's live reasoning/thought text (native
    *  extended-thinking models) — a transient live-preview beat, not persisted to
    *  the ledger (mirrors the main turn's dimmed "Thinking" block, scoped per
@@ -108,6 +112,9 @@ export interface TaskToolOptions {
  *  should either run sequentially (separate `task` calls) or coordinate — jeo has
  *  no in-batch peer channel yet, so overlapping-scope tasks MUST be sequential. */
 export const MAX_FANOUT = 4;
+/** Task-tool policy: cap independently launched detached runs at four per turn.
+ * The registry remains reusable by other execution paths with their own limits. */
+const MAX_ACTIVE_DETACHED_SUBAGENTS = 4;
 
 /** Small bounded reroute budget for a SUBAGENT's own 429 (distinct from
  *  launch.ts's `ROUTE_FALLBACK_MAX_ATTEMPTS`, default 3): a subagent is already
@@ -167,12 +174,25 @@ function createSteerHub(drain?: () => string[]) {
 }
 
 /** One-line protocol description appended to the launch system prompt. Pass a
- *  config so CONFIG-DECLARED custom roles are advertised to the model too. */
+ *  config so CONFIG-DECLARED custom roles are advertised to the model too.
+ *
+ *  The single-vs-fan-out shapes are spelled out as two SEPARATE literal
+ *  examples (not the terse `task|tasks[]` shorthand this replaced) — live
+ *  reproduction (multiple real models, including a native-tool-calling-capable
+ *  one) showed models repeatedly sending `tasks` as a JSON-STRINGIFIED array
+ *  or a single task string instead of a real JSON array, self-diagnosing
+ *  "I'm passing tasks as a string instead of as an actual array" turn after
+ *  turn until the loop guard stopped them. `task` has no native function-
+ *  calling schema (its shape is too variable for one static schema) — EVERY
+ *  provider, including native-schema-capable ones, learns this tool's shape
+ *  from this exact prose line, so ambiguity here directly costs reliability
+ *  across the board, not just for the JSON-in-prose fallback providers. */
 export function taskToolProtocolLine(config?: Pick<Config, "subagents">): string {
   return (
-    `task   {role, task|tasks[], context?}  — delegate to a subagent ` +
-    `(role: ${subagentRoleIds(config).join("|")}; executor can edit, planner/architect/critic are read-only). ` +
-    `Pass 'tasks' (array) to fan out — ALL roles run concurrently (bounded); scope each executor task to disjoint files (no shared-file coordination channel between concurrent tasks — use sequential task calls if scopes overlap). Integrate the findings yourself.`
+    `task   single: {role?, task, context?, detached?:true}  —  fan-out: {role?, tasks:["task 1", "task 2", ...]} (fan-out cannot be detached) ` +
+    `— delegate to a subagent (role: ${subagentRoleIds(config).join("|")}; executor can edit, planner/architect/critic are read-only). ` +
+    `'tasks' MUST be a real JSON array (of strings, or {task, context?} objects) — NEVER a JSON-stringified array, NEVER a single task string. ` +
+    `All items in 'tasks' run concurrently (bounded); scope each executor task to disjoint files (no shared-file coordination channel between concurrent tasks — use sequential task calls if scopes overlap). Integrate the findings yourself.`
   );
 }
 
@@ -221,6 +241,8 @@ export interface RunSubagentOptions {
   steer?: () => string[];
   /** 1-based position within a fan-out/parallel batch, for event tagging. */
   slot?: { index: number; total: number };
+  /** Stable registry id for a detached run's lifecycle events. */
+  detachedId?: string;
   /** Pre-loaded project context to avoid re-scanning AGENTS.md per batch item. */
   projectContext?: ProjectContextFile[];
   /** BATCH-scoped (not per-call) credential scopes already known exhausted this
@@ -288,11 +310,14 @@ export async function runSubagentOnce(
   cwd: string,
   opts: RunSubagentOptions,
 ): Promise<SubagentRunResult> {
-  const { steer, slot, projectContext: preloadedContext, signal } = opts;
-  // Tag every live event with its fan-out slot so a parent monitor can tell
-  // task 1 from task 3 when several same-role subagents stream concurrently.
+  const { steer, slot, detachedId, projectContext: preloadedContext, signal } = opts;
+  // Tag live events with their fan-out slot and/or detached registry identity.
   const emit = (ev: TaskSubEvent) =>
-    opts.onEvent?.(slot ? { ...ev, index: slot.index, total: slot.total } : ev);
+    opts.onEvent?.({
+      ...ev,
+      ...(slot ? { index: slot.index, total: slot.total } : {}),
+      ...(detachedId ? { id: detachedId, detached: true } : {}),
+    });
   const initialModel = opts.modelOverride || resolveSubagentModel(role.id, opts.config);
   const maxSteps = resolveSubagentMaxSteps(role.id, opts.config);
   // gjc parity: a role may pin its own reasoning budget; absent = inherit the
@@ -524,6 +549,8 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     extra: {
       steer?: () => string[];
       slot?: { index: number; total: number };
+      /** Stable registry id for detached-run lifecycle events. */
+      detachedId?: string;
       projectContext?: ProjectContextFile[];
       /** Overrides opts.signal — a detached run uses its own registry signal so it
        *  is cancellable independently of the parent turn. */
@@ -541,6 +568,7 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
       onEvent: opts.onEvent,
       steer: extra.steer,
       slot: extra.slot,
+      detachedId: extra.detachedId,
       projectContext: extra.projectContext,
       excludedCredentialScopes: extra.excludedCredentialScopes,
       modelOverride: extra.modelOverride,
@@ -554,9 +582,32 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     }
     const ctx = (c: unknown) => (typeof c === "string" && c.trim() ? `\n\nContext:\n${c.trim()}` : "");
 
+    // Native/function-call adapters normally preserve boolean values, but the prose-only
+    // protocol can still yield the exact string "true" from otherwise valid model JSON.
+    // This is an unambiguous serialization mistake; treating it as synchronous defeats
+    // detached dispatch while the parent waits for the very task it intended to background.
+    const detached = args.detached === true
+      || (typeof args.detached === "string" && args.detached.trim().toLowerCase() === "true");
+
     // Fan-out form: `tasks: [ "assignment" | {task|assignment|prompt, context?} ]`.
-    if (Array.isArray(args.tasks)) {
-      const items = (args.tasks as unknown[])
+    // Live-reproduced (v0.8.42, multiple real models across two different providers,
+    // including a native-tool-calling-capable one): even with an explicit, example-driven
+    // protocol line, models repeatedly send `tasks` as a JSON-STRINGIFIED array (correct
+    // content, wrong JSON type) rather than a real array — a classifiable, unambiguous
+    // mistake, not a genuinely different intent. Accept it rather than hard-reject: any
+    // string that itself parses to an array is exactly this mistake.
+    const tasksArg = typeof args.tasks === "string"
+      ? (() => { try { const p = JSON.parse(args.tasks as string); return Array.isArray(p) ? p : args.tasks; } catch { return args.tasks; } })()
+      : args.tasks;
+    if (Array.isArray(tasksArg)) {
+      if (detached) {
+        return {
+          success: false,
+          output: "",
+          error: "Detached task fan-out is not supported. Launch each independent task with detached:true so each has its own lifecycle id and control handle.",
+        };
+      }
+      const items = (tasksArg as unknown[])
         .map(entry => {
           if (typeof entry === "string") return { task: entry.trim(), context: "" };
           if (entry && typeof entry === "object") {
@@ -661,9 +712,20 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     // parent can keep working, then list/inspect/await/cancel via the `subagent`
     // tool. Live peer messaging (steer/irc) DOES reach a detached run — it drains
     // its own registry inbox (registry.steerDrainFor(id)) between its own steps.
-    if (args.detached === true && opts.registry) {
+    if (detached && opts.registry) {
+      if (opts.registry.running().length >= MAX_ACTIVE_DETACHED_SUBAGENTS) {
+        return {
+          success: false,
+          output: "",
+          error: `Detached subagent limit reached (${MAX_ACTIVE_DETACHED_SUBAGENTS} running). Await or cancel a running subagent before launching another.`,
+        };
+      }
       const rec = opts.registry.launch(role.id, taskText, (signal, id) =>
-        runOne(role, taskText, ctx(args.context), cwd, { signal, steer: opts.registry!.steerDrainFor(id) }),
+        runOne(role, taskText, ctx(args.context), cwd, {
+          signal,
+          steer: opts.registry!.steerDrainFor(id),
+          detachedId: id,
+        }),
       );
       // Remote subagent visibility/control over Telegram (gjc daemon parity, see
       // `src/agent/notify/`): best-effort, no-op unless `notifications.enabled`.

package/src/agent/tool-schemas.ts

@@ -116,6 +116,22 @@ const SCHEMAS: Record<string, NativeToolSchema> = {
       required: ["calculations"],
     },
   },
+  monitor: {
+    name: "monitor",
+    description: "Start a bounded background stdout monitor. Non-persistent monitors stop after their first output line; control the returned job id with the job tool.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: STRING,
+        kind: { type: "string", enum: ["log", "poll", "watch", "other"] },
+        description: STRING,
+        timeout: { type: "number" },
+        persistent: { type: "boolean" },
+        cwd: STRING,
+      },
+      required: ["command", "kind", "description"],
+    },
+  },
   done: {
     name: "done",
     description: "Call when the task is fully implemented AND verified. The reason is shown to the user as your message.",

package/src/agent/tools.ts

@@ -111,6 +111,10 @@ export async function assertBashAllowed(
   }
 }
 
+function cancelledMutationResult(signal?: AbortSignal): ToolResult | undefined {
+  return signal?.aborted ? { success: false, output: "", error: "Operation cancelled" } : undefined;
+}
+
 /**
  * Parse a read line selector into sorted, merged, inclusive [start,end] ranges.
  * Segments are comma-separated; each is one of: "a-b" (range), "a-" (a→EOF),
@@ -312,15 +316,22 @@ export async function readTool(
 export async function writeTool(
   filePath: string,
   content: string,
-  cwd: string = process.cwd()
+  cwd: string = process.cwd(),
+  signal?: AbortSignal,
 ): Promise<ToolResult> {
   try {
+    const aborted = cancelledMutationResult(signal);
+    if (aborted) return aborted;
     if (typeof filePath !== "string" || filePath.trim() === "") {
       return { success: false, output: "", error: 'write requires a non-empty "filePath".' };
     }
     await assertMutationAllowed(filePath, cwd);
+    const abortedAfterGuard = cancelledMutationResult(signal);
+    if (abortedAfterGuard) return abortedAfterGuard;
     const absPath = path.resolve(cwd, filePath);
     await fs.mkdir(path.dirname(absPath), { recursive: true });
+    const abortedBeforeWrite = cancelledMutationResult(signal);
+    if (abortedBeforeWrite) return abortedBeforeWrite;
     await fs.writeFile(absPath, content, "utf-8");
     markRead(absPath); // own change counts as having seen the file
     return { success: true, output: `Successfully wrote ${content.length} characters to ${filePath}` };
@@ -360,9 +371,12 @@ export function parseEditHunks(block: string): { search: string; replace: string
 export async function editTool(
   filePath: string,
   editBlock: string,
-  cwd: string = process.cwd()
+  cwd: string = process.cwd(),
+  signal?: AbortSignal,
 ): Promise<ToolResult> {
   try {
+    const aborted = cancelledMutationResult(signal);
+    if (aborted) return aborted;
     if (typeof filePath !== "string" || filePath.trim() === "") {
       return { success: false, output: "", error: 'edit requires a non-empty "filePath".' };
     }
@@ -370,6 +384,8 @@ export async function editTool(
       return { success: false, output: "", error: 'edit requires a non-empty "editBlock" (≔ directive or <<<<<<< SEARCH block).' };
     }
     await assertMutationAllowed(filePath, cwd);
+    const abortedAfterGuard = cancelledMutationResult(signal);
+    if (abortedAfterGuard) return abortedAfterGuard;
     const absPath = path.resolve(cwd, filePath);
     let content = await fs.readFile(absPath, "utf-8");
 
@@ -581,6 +597,8 @@ export async function editTool(
       };
     }
 
+    const abortedBeforeWrite = cancelledMutationResult(signal);
+    if (abortedBeforeWrite) return abortedBeforeWrite;
     await fs.writeFile(absPath, content, "utf-8");
     markRead(absPath); // own change counts as having seen the file
     return { success: true, output: `Successfully updated ${filePath}` };
@@ -1076,18 +1094,25 @@ export async function lsTool(
  */
 export async function mkdirTool(
   dirPath: string,
-  cwd: string = process.cwd()
+  cwd: string = process.cwd(),
+  signal?: AbortSignal,
 ): Promise<ToolResult> {
   try {
+    const aborted = cancelledMutationResult(signal);
+    if (aborted) return aborted;
     if (typeof dirPath !== "string" || dirPath.trim() === "") {
       return { success: false, output: "", error: 'mkdir requires a non-empty "dirPath".' };
     }
     await assertMutationAllowed(dirPath, cwd);
+    const abortedAfterGuard = cancelledMutationResult(signal);
+    if (abortedAfterGuard) return abortedAfterGuard;
     const abs = path.resolve(cwd, dirPath);
     const existing = await fs.stat(abs).catch(() => null);
     if (existing && !existing.isDirectory()) {
       return { success: false, output: "", error: `Path exists and is not a directory: ${dirPath}` };
     }
+    const abortedBeforeMkdir = cancelledMutationResult(signal);
+    if (abortedBeforeMkdir) return abortedBeforeMkdir;
     await fs.mkdir(abs, { recursive: true });
     return { success: true, output: `Directory ready: ${dirPath}` };
   } catch (err: any) {
@@ -1105,13 +1130,18 @@ export async function mkdirTool(
 export async function deleteTool(
   targetPath: string,
   cwd: string = process.cwd(),
-  recursive: boolean = false
+  recursive: boolean = false,
+  signal?: AbortSignal,
 ): Promise<ToolResult> {
   try {
+    const aborted = cancelledMutationResult(signal);
+    if (aborted) return aborted;
     if (typeof targetPath !== "string" || targetPath.trim() === "") {
       return { success: false, output: "", error: 'delete requires a non-empty "path".' };
     }
     await assertMutationAllowed(targetPath, cwd);
+    const abortedAfterGuard = cancelledMutationResult(signal);
+    if (abortedAfterGuard) return abortedAfterGuard;
     const abs = path.resolve(cwd, targetPath);
     if (abs === path.resolve(cwd)) {
       return { success: false, output: "", error: "Refusing to delete the working directory itself." };
@@ -1123,6 +1153,8 @@ export async function deleteTool(
     if (st.isDirectory() && !recursive) {
       return { success: false, output: "", error: `${targetPath} is a directory — pass recursive:true to remove it and its contents.` };
     }
+    const abortedBeforeDelete = cancelledMutationResult(signal);
+    if (abortedBeforeDelete) return abortedBeforeDelete;
     await fs.rm(abs, { recursive, force: false });
     readThisSession.delete(abs); // a future edit against this path must read it again first
     return { success: true, output: `Deleted ${st.isDirectory() ? "directory" : "file"}: ${targetPath}` };

package/src/ai/providers/anthropic.ts

@@ -255,6 +255,7 @@ export function anthropicPayload(
   credential: Credential = { kind: "none", provider: "anthropic" },
   stripArtifacts = false,
   disableFallback = false,
+  disableEffort = false,
 ): string {
   const model = stripAnthropicPrefix(options.model);
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
@@ -306,16 +307,21 @@ export function anthropicPayload(
       // Opus/Sonnet 4.6+: the model decides how much to think. `display: "summarized"` is
       // REQUIRED on Opus 4.7+ or thinking content is omitted from the response (the empty-thought
       // bug); older adaptive models (4.6) reject the field, so it is gated. Effort rides
-      // output_config — there is no budget_tokens on this transport.
+      // output_config — there is no budget_tokens on this transport. `disableEffort` (fail-safe
+      // retry after a live "does not support the effort parameter" 400 — some model variants
+      // classify as adaptive-transport by name/version but still reject this field) drops ONLY
+      // output_config; `thinking` alone is still valid, the model just uses its own default depth.
       payload.thinking = supportsAdaptiveThinkingDisplay(model)
         ? { type: "adaptive", display: "summarized" }
         : { type: "adaptive" };
-      payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
+      if (!disableEffort) payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
     } else {
       // Budget-based extended thinking. `display: "summarized"` keeps human-readable thought
-      // streaming. The 4.5 (budget-effort) transport also carries an output_config effort.
+      // streaming. The 4.5 (budget-effort) transport also carries an output_config effort —
+      // unless `disableEffort` is set (see the adaptive branch above for the same rationale;
+      // this mirrors Haiku 4.5's already-proven-working budget_tokens-without-effort combination).
       payload.thinking = { type: "enabled", budget_tokens: thinkingBudget, display: "summarized" };
-      if (thinkingMode === "budget-effort") payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
+      if (thinkingMode === "budget-effort" && !disableEffort) payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
     }
   } else if (includeTemperature && options.temperature !== undefined) {
     payload.temperature = options.temperature;
@@ -345,13 +351,14 @@ export function anthropicRequest(
   includeTemperature: boolean,
   stripArtifacts = false,
   disableFallback = false,
+  disableEffort = false,
 ): { url: string; headers: Record<string, string>; body: string } {
   return {
     // Anthropic-compatible providers (z.ai, MiniMax, …) accept the Messages wire
     // format at their own host; an explicit baseUrl pins `${base}/v1/messages`.
     url: options.baseUrl ? `${options.baseUrl.replace(/\/$/, "")}/v1/messages` : ANTHROPIC_URL,
     headers: { ...headersFor(credential, stream, stripAnthropicPrefix(options.model), options.baseUrl, disableFallback), ...options.extraHeaders },
-    body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts, disableFallback),
+    body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts, disableFallback, disableEffort),
   };
 }
 
@@ -376,6 +383,18 @@ function isFallbackUnsupportedError(status: number, detail: string): boolean {
   return status === 400 && /fallback/i.test(detail);
 }
 
+/** A 400 naming "effort"/"output_config" means this specific model variant rejects the
+ *  effort field even though its name/version classifies it onto a transport that normally
+ *  carries one (live-reproduced: a rate-limit-fallback-selected dated snapshot,
+ *  `claude-sonnet-4-5-20250929`, 400'd with "This model does not support the effort
+ *  parameter" — the same wording already known for Haiku 4.5, but on a model this
+ *  codebase's version-based classification did not expect to reject it). Retry once with
+ *  `output_config` dropped (thinking/budget_tokens, if any, stay — only the effort field
+ *  itself is unsupported) so the turn survives instead of dying on an avoidable 400. */
+function isEffortUnsupportedError(status: number, detail: string): boolean {
+  return status === 400 && /effort/i.test(detail) && /output_config|not support/i.test(detail);
+}
+
 /** gjc parity (getSafeAnthropicHeaderEvidence): fold Anthropic's rate-limit response
  *  headers into a 429's error detail so the retry classifier can see them. The decisive
  *  usage-exhaustion signal (`anthropic-ratelimit-unified-overage-disabled-reason:
@@ -401,8 +420,9 @@ async function postAnthropic(
   let includeTemperature = true;
   let stripArtifacts = false;
   let disableFallback = false;
+  let disableEffort = false;
 
-  for (let attempt = 1; attempt <= 4; attempt++) {
+  for (let attempt = 1; attempt <= 5; attempt++) {
     const { url, headers, body } = anthropicRequest(
       messages,
       options,
@@ -411,6 +431,7 @@ async function postAnthropic(
       includeTemperature,
       stripArtifacts,
       disableFallback,
+      disableEffort,
     );
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (response.ok) return response;
@@ -428,6 +449,10 @@ async function postAnthropic(
       disableFallback = true;
       continue;
     }
+    if (isEffortUnsupportedError(response.status, detail) && !disableEffort) {
+      disableEffort = true;
+      continue;
+    }
 
     // Unrecoverable error, or all retries for the active error type spent
     const enrichedDetail = response.status === 429 ? `${detail}${anthropicRateLimitEvidence(response.headers)}` : detail;

package/src/commands/launch/slash-handlers.ts

@@ -10,6 +10,7 @@ import { taskToolProtocolLine } from "../../agent/task-tool";
 import { TODO_TOOL_PROTOCOL_LINE } from "../../agent/todo-tool";
 import { SUBAGENT_TOOL_PROTOCOL_LINE } from "../../agent/subagent-tool";
 import { JOB_TOOL_PROTOCOL_LINE } from "../../agent/job-tool";
+import { MONITOR_TOOL_PROTOCOL_LINE } from "../../agent/monitor-tool";
 import { IRC_TOOL_PROTOCOL_LINE } from "../../agent/irc-tool";
 import { GOAL_TOOL_PROTOCOL_LINE } from "../../agent/goal-tool";
 import { hotkeysLines, contextUsageLines } from "./slash-views";
@@ -50,6 +51,7 @@ export async function handleTools(ctx: SlashContext): Promise<SlashResult> {
   lines.push(`  ${TODO_TOOL_PROTOCOL_LINE}`);
   lines.push(`  ${SUBAGENT_TOOL_PROTOCOL_LINE}`);
   lines.push(`  ${JOB_TOOL_PROTOCOL_LINE}`);
+  lines.push(`  ${MONITOR_TOOL_PROTOCOL_LINE}`);
   lines.push(`  ${IRC_TOOL_PROTOCOL_LINE}`);
   lines.push(`  ${GOAL_TOOL_PROTOCOL_LINE}`);
   return { lines };

package/src/commands/launch/stream.ts

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { type AgentLoopEvents } from "../../agent/engine";
 import { type TaskSubEvent } from "../../agent/task-tool";
+import { type MonitorJobEvent } from "../../agent/job-registry";
 import { categoryBadge } from "../../tui/components/category-index";
 import { summarizeForgeInvocation } from "../../tui/components/forge";
 import { formatDuration, formatUsage } from "../../tui/components/duration";
@@ -44,7 +45,8 @@ function streamResultSuffix(tool: string, ok: boolean, output: string | undefine
 
 export function formatTaskSubEvent(e: TaskSubEvent): string {
   const role = e.role || "subagent";
-  const roleLabel = e.index && e.total ? `${role.toUpperCase()}[${e.index}/${e.total}]` : role.toUpperCase();
+  const detachedLabel = e.detached && e.id ? ` [${e.id}]` : "";
+  const roleLabel = `${e.index && e.total ? `${role.toUpperCase()}[${e.index}/${e.total}]` : role.toUpperCase()}${detachedLabel}`;
   const tokTag = e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : "";
   const detail = firstOutputLine(e.detail);
   const summary = e.summary ? ` — ${e.summary}` : "";
@@ -66,6 +68,19 @@ export function logTaskSubEvent(e: TaskSubEvent, log: (line: string) => void = (
   const line = formatTaskSubEvent(e);
   if (line) log(line);
 }
+export function formatMonitorJobEvent(e: MonitorJobEvent): string {
+  const label = `${e.record.id} · ${e.record.category} · ${e.record.description}`;
+  if (e.type === "start") return `${categoryBadge("progress")} ${chalk.cyan("monitor ▸")} ${label}`.slice(0, 240);
+  if (e.type === "line") {
+    const line = firstOutputLine(e.line);
+    return `${categoryBadge("progress")} ${chalk.cyan("monitor │")} ${label}${line ? ` — ${line}` : ""}`.slice(0, 240);
+  }
+  return `${categoryBadge("progress")} ${chalk.cyan("monitor └")} ${label} ${chalk.dim("done")}`.slice(0, 240);
+}
+
+export function logMonitorJobEvent(e: MonitorJobEvent, log: (line: string) => void = (s: string) => console.log(s)): void {
+  log(formatMonitorJobEvent(e));
+}
 
 export function createStreamEvents(
   _maxSteps: number,