negotium 0.23.2 → 0.23.4

package/dist/registry.js

@@ -2,7 +2,7 @@
 import {
   encodeClaudeCwd,
   writeClaudeRollout
-} from "./chunk-cez5m5hm.js";
+} from "./chunk-pwafy9bb.js";
 import {
   CLAUDE_EFFORT_VALUES,
   CODEX_EFFORT_VALUES,
@@ -17,7 +17,7 @@ import {
   hostedCodexHomePath,
   logger,
   writeCodexRollout
-} from "./chunk-6cnpkzkb.js";
+} from "./chunk-vtd5kn4n.js";
 
 // ../../packages/core/src/agents/claude-registry.ts
 import { existsSync, mkdirSync, readdirSync, renameSync, unlinkSync } from "fs";
@@ -132,7 +132,7 @@ var codexRegistryOperations = {
     return { sessionId: threadId, rolloutPath };
   },
   async forkSession({ parentSessionId }) {
-    const { forkCodexSession } = await import("./chunk-s34sv3d2.js");
+    const { forkCodexSession } = await import("./chunk-ggdwn8d5.js");
     return await forkCodexSession(parentSessionId);
   },
   async cleanupRollouts({ sessionIds }) {

package/dist/rollout.js

@@ -3,7 +3,7 @@ import {
   encodeClaudeCwd,
   repairPoisonedRollout,
   writeClaudeRollout
-} from "./chunk-cez5m5hm.js";
+} from "./chunk-pwafy9bb.js";
 import {
   configureRolloutHost,
   decodeUuidV7Timestamp,
@@ -16,7 +16,7 @@ import {
   readLatestCodexContextUsage,
   readLatestCodexPatchPreview,
   writeCodexRollout
-} from "./chunk-6cnpkzkb.js";
+} from "./chunk-vtd5kn4n.js";
 
 // src/rollout.ts
 import { fileURLToPath } from "url";

package/dist/runtime/src/agents/claude-notices.ts

@@ -0,0 +1,130 @@
+/**
+ * Non-fatal Claude Agent SDK notices → user-visible status lines.
+ *
+ * Fatality is decided only by the terminal `result` message or a CLI exit
+ * (see claude-provider.ts); nothing here may end a turn. The SDK adds and
+ * renames system subtypes often, so the handled subtypes are keyed by the
+ * SDK's own types: a rename or removal fails `tsc` on upgrade, while a
+ * subtype this table does not know is only debug-logged at runtime.
+ */
+
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import { logger } from "#platform/logger";
+
+type SystemMessage = Extract<SDKMessage, { type: "system" }>;
+type SystemSubtype = SystemMessage["subtype"];
+type SystemOf<S extends SystemSubtype> = Extract<SystemMessage, { subtype: S }>;
+type RateLimitEvent = Extract<SDKMessage, { type: "rate_limit_event" }>;
+type ApiError = SystemOf<"api_retry">["error"];
+type RateLimitType = NonNullable<RateLimitEvent["rate_limit_info"]["rateLimitType"]>;
+
+// Exhaustive over the SDK unions, so a new reason or limit fails `tsc`.
+const API_ERROR_TEXT: Record<ApiError, string> = {
+  overloaded: "Claude is overloaded",
+  rate_limit: "Claude rate limit hit",
+  server_error: "Claude API error",
+  unknown: "Claude request failed",
+  authentication_failed: "Claude sign-in failed",
+  oauth_org_not_allowed: "Organization not allowed for Claude",
+  account_on_hold: "Claude account is on hold",
+  verification_required: "Claude account needs verification",
+  billing_error: "Claude billing issue",
+  invalid_request: "Claude rejected the request",
+  model_not_found: "Claude model not found",
+  max_output_tokens: "Claude reply hit the length limit",
+  cloud_credential_error: "Cloud credentials failed",
+};
+
+const RATE_LIMIT_TEXT: Record<RateLimitType, string> = {
+  five_hour: "5-hour",
+  seven_day: "weekly",
+  seven_day_opus: "weekly Opus",
+  seven_day_sonnet: "weekly Sonnet",
+  seven_day_overage_included: "weekly",
+  overage: "extra usage",
+};
+
+const DENIAL_TEXT: Record<string, string> = {
+  rule: "by a permission rule",
+  mode: "by the permission mode",
+  classifier: "by the safety check",
+  asyncAgent: "for a background agent",
+};
+
+/** `claude-opus-5-5` → `Opus 5.5`; other ids pass through unchanged. */
+function modelLabel(id: string): string {
+  const match = /^claude-([a-z]+)-(\d+)-(\d+)/.exec(id);
+  if (!match) return id;
+  const [, family = "", major, minor] = match;
+  return `${family.charAt(0).toUpperCase()}${family.slice(1)} ${major}.${minor}`;
+}
+
+const SYSTEM_NOTICES: {
+  [S in SystemSubtype]?: (message: SystemOf<S>) => string | undefined;
+} = {
+  api_retry: (m) => {
+    const reason =
+      m.error_status === null
+        ? "Lost connection to Claude"
+        : (API_ERROR_TEXT[m.error] ?? "Claude request failed");
+    const delay = Math.round(m.retry_delay_ms / 1000);
+    const when = delay > 0 ? `in ${delay}s` : "now";
+    return `${reason} · retrying ${when} (${m.attempt}/${m.max_retries})`;
+  },
+  model_refusal_fallback: (m) =>
+    m.direction === "retry"
+      ? `${modelLabel(m.original_model)} declined · ${modelLabel(m.fallback_model)} is answering instead`
+      : m.content || undefined,
+  model_refusal_no_fallback: (m) => `${modelLabel(m.original_model)} declined this request`,
+  permission_denied: (m) => {
+    const tool = m.tool_name.split("__").at(-1) || m.tool_name;
+    const why = m.decision_reason
+      ? `: ${m.decision_reason}`
+      : ` ${DENIAL_TEXT[m.decision_reason_type ?? ""] ?? ""}`.trimEnd();
+    return `${tool} was blocked${why}`;
+  },
+  informational: (m) =>
+    m.prevent_continuation || m.level === "warning" || m.level === "suggestion"
+      ? m.content
+      : undefined,
+  mirror_error: (m) => {
+    logger.warn({ error: m.error }, "claudeProvider: transcript mirror batch dropped");
+    return undefined;
+  },
+};
+
+function rateLimitNotice(m: RateLimitEvent): string | undefined {
+  const { status, rateLimitType } = m.rate_limit_info;
+  const limit = rateLimitType ? `${RATE_LIMIT_TEXT[rateLimitType] ?? ""} `.trimStart() : "";
+  if (status === "allowed_warning") return `Nearing your ${limit}Claude usage limit`;
+  if (status === "rejected") return `Reached your ${limit}Claude usage limit`;
+  return undefined;
+}
+
+/**
+ * Status text for a non-terminal SDK message, or undefined when it should not
+ * be shown. Never throws and never classifies anything as an error.
+ */
+export function claudeNoticeStatus(message: SDKMessage): string | undefined {
+  try {
+    if (message.type === "rate_limit_event") return rateLimitNotice(message);
+    if (message.type !== "system") return undefined;
+    const handler = SYSTEM_NOTICES[message.subtype] as
+      | ((m: SystemMessage) => string | undefined)
+      | undefined;
+    if (!handler) {
+      logger.debug(
+        { subtype: message.subtype, msg: message },
+        "claudeProvider: system message (unhandled subtype)",
+      );
+      return undefined;
+    }
+    const status = handler(message);
+    if (status) logger.warn({ subtype: message.subtype, status }, "claudeProvider: notice");
+    return status;
+  } catch (err) {
+    // A field reshaped by an SDK upgrade must not take the turn down with it.
+    logger.debug({ err, msg: message }, "claudeProvider: notice mapping failed");
+    return undefined;
+  }
+}

package/dist/runtime/src/agents/claude-provider.ts

@@ -19,6 +19,7 @@ import type {
   ContentBlockParam,
   ImageBlockParam,
 } from "@anthropic-ai/sdk/resources/messages/messages.mjs";
+import { claudeNoticeStatus } from "#agents/claude-notices";
 import { claudeRegistry } from "#agents/claude-registry";
 import { deepMapStrings } from "#agents/deep-map";
 import {
@@ -703,18 +704,15 @@ export async function* claudeProvider(opts: AgentQueryOptions): AsyncGenerator<U
         continue;
       }
 
-      // --- System init ---
-      if (message.type === "system") {
-        const m = message as SDKSystemMessage;
-        if (m.subtype === "init") {
-          yield { type: "session", sessionId: m.session_id };
+      // --- System init + non-fatal notices ---
+      // Retries, refusals, auto-denials and usage warnings become status lines;
+      // only the terminal `result` (or a CLI exit) can fail the turn.
+      if (message.type === "system" || message.type === "rate_limit_event") {
+        if (message.type === "system" && message.subtype === "init") {
+          yield { type: "session", sessionId: (message as SDKSystemMessage).session_id };
         } else {
-          // Log all other system messages (task_updated, task_progress,
-          // task_notification, etc.) so we can observe lifecycle events.
-          logger.debug(
-            { subtype: m.subtype, msg: m },
-            "claudeProvider: system message (unhandled subtype)",
-          );
+          const status = claudeNoticeStatus(message);
+          if (status) yield { type: "status", content: status };
         }
         continue;
       }

package/dist/runtime/src/agents/codex-provider.ts

@@ -37,6 +37,7 @@ import {
 } from "#agents/execution-host";
 import {
   type CodexTokenTotals,
+  codexThreadHasSystemPrompt,
   migrateCodexRolloutNativeMultiAgentMetadata,
   readCodexPatchCallIds,
   readLatestCodexContextUsage,
@@ -64,6 +65,18 @@ type CodexEventUsage = {
 const CODEX_HOOK_TRUST_BYPASS_NOTICE =
   "`--dangerously-bypass-hook-trust` is enabled. Enabled hooks may run without review for this invocation.";
 
+/**
+ * One short status line from a free-form Codex notice. Codex sends prose with
+ * no stable code, so only the shape is used: its first sentence, labeled as
+ * Codex's. The full text stays in the log.
+ */
+export function codexNoticeStatus(message: string): string {
+  const firstLine = message.trim().split("\n")[0]?.trim() ?? "";
+  const sentence = /^.*?[.!?](?=\s|$)/.exec(firstLine)?.[0] ?? firstLine;
+  if (!sentence) return "Codex notice";
+  return /^codex\b/i.test(sentence) ? sentence : `Codex: ${sentence}`;
+}
+
 function sameCodexUsage(usage: CodexEventUsage, total: CodexTokenTotals): boolean {
   return (
     usage.input_tokens === total.inputTokens &&
@@ -760,7 +773,6 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
       hooks: vaultHook.hooks,
       model_catalog_json: codexModelCatalogPath,
       mcp_servers: codexMcpServers,
-      ...(opts.toolPolicy ? { sandbox_permissions: [] } : {}),
     },
   });
 
@@ -793,13 +805,20 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
   let currentSessionId = opts.sessionId;
   let usageBaseline = currentSessionId ? readLatestCodexTokenTotals(currentSessionId) : undefined;
 
-  // Codex SDK has no systemPrompt option. A resumed thread may have been
-  // synthesized from a captured shell, so always refresh the current runtime
-  // instructions instead of trusting historical developer/environment data.
+  // Codex SDK has no systemPrompt option, so the instructions ride in the user
+  // prompt and stay in thread history from then on. Re-sending them every turn
+  // piles a full copy into history per message. Send them on a new thread, or
+  // when the resumed history lacks the current text (synthesized from a
+  // captured shell, or the instructions changed since they were last sent).
   let thread = currentSessionId
     ? codex.resumeThread(currentSessionId, threadOptions)
     : codex.startThread(threadOptions);
-  let prompt = promptForThread(opts, true);
+  let prompt = promptForThread(
+    opts,
+    !currentSessionId ||
+      !opts.systemPrompt ||
+      !codexThreadHasSystemPrompt(currentSessionId, opts.systemPrompt),
+  );
 
   let agentTextSoFar = "";
   let currentAgentMessageId: string | undefined;
@@ -844,6 +863,9 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
       trackedPids.pids = [];
       let heartbeatTriggered = false;
       let attemptCompleted = false;
+      let turnFailed = false;
+      // Last top-level `error` event; fatal only if the turn never completes.
+      let streamError: string | undefined;
       let heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
 
       const scheduleHeartbeat = () => {
@@ -927,6 +949,7 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
               cache_write_input_tokens?: number;
             };
             error?: { message?: string };
+            message?: string;
           };
 
           switch (event.type) {
@@ -1035,9 +1058,14 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
                   yield fileEvent;
                 }
               } else if (item.type === "error") {
+                // The SDK types error items as non-fatal: the turn keeps running
+                // and real failures arrive as `turn.failed` or a top-level
+                // `error`. Yielding an error here would end the turn (and fail
+                // compaction) over a notice such as an ignored config key.
                 const message = String(item.message ?? "");
                 if (message !== CODEX_HOOK_TRUST_BYPASS_NOTICE) {
-                  yield { type: "error", content: message };
+                  logger.warn({ message }, "codexProvider: codex non-fatal error item");
+                  yield { type: "status", content: codexNoticeStatus(message) };
                 }
               }
               break;
@@ -1071,7 +1099,19 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
               break;
             }
 
+            case "error": {
+              // `codex exec` keeps running after a top-level error (e.g. a stream
+              // error it retries); only `turn.failed` or a turn that never
+              // completes is fatal. Keep the message to explain the latter.
+              const message = event.message || "Codex stream error";
+              logger.warn({ message }, "codexProvider: codex stream error event");
+              streamError = message;
+              yield { type: "status", content: codexNoticeStatus(message) };
+              break;
+            }
+
             case "turn.failed": {
+              turnFailed = true;
               stopReason = "error";
               yield {
                 type: "error",
@@ -1084,6 +1124,11 @@ export async function* codexProvider(opts: AgentQueryOptions): AsyncGenerator<Un
               break;
           }
         }
+
+        if (!attemptCompleted && !turnFailed && streamError) {
+          stopReason = "error";
+          yield { type: "error", content: streamError };
+        }
       } catch (err) {
         if (abortSignal?.aborted) return;
         if (err instanceof Error && err.name === "AbortError") {

package/dist/runtime/src/agents/rollout/codex.ts

@@ -467,6 +467,64 @@ export function extractCodexForkedFromId(jsonl: string): string | undefined {
   }
 }
 
+/**
+ * Text of the latest user turn that carried negotium's `[System Instructions]`
+ * preamble. Codex has no system-prompt option, so the provider inlines it into
+ * the user prompt; this reports what the resumed thread already holds.
+ */
+export function extractLatestCodexSystemInstructionsTurn(jsonl: string): string | undefined {
+  const lines = jsonl.trimEnd().split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (!line.includes("[System Instructions]")) continue;
+    try {
+      const entry = JSON.parse(line) as {
+        type?: string;
+        payload?: { type?: string; role?: string; content?: Array<{ text?: unknown }> };
+      };
+      if (entry.type !== "response_item") continue;
+      if (entry.payload?.type !== "message" || entry.payload.role !== "user") continue;
+      const text = (entry.payload.content ?? [])
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .join("");
+      if (text.startsWith("[System Instructions]\n")) return text;
+    } catch {
+      // A concurrently appended final line may be incomplete; keep scanning.
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Whether the thread's history already ends its instruction trail with exactly
+ * `systemPrompt`. Synthesized rollouts (agent switch, fork fallback) carry no
+ * instructions, and a changed prompt must be re-sent, so both report false.
+ */
+export function codexThreadHasSystemPrompt(
+  threadId: string,
+  systemPrompt: string,
+  depth = 0,
+): boolean {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path) return false;
+  try {
+    const jsonl = readFileSync(path, "utf8");
+    const latest = extractLatestCodexSystemInstructionsTurn(jsonl);
+    if (latest !== undefined) {
+      return latest.startsWith(`[System Instructions]\n${systemPrompt}\n\n`);
+    }
+    if (depth >= 8) return false;
+    // A paginated fork may not copy the parent's items into its own rollout.
+    const parentId = extractCodexForkedFromId(jsonl);
+    return parentId && parentId !== threadId
+      ? codexThreadHasSystemPrompt(parentId, systemPrompt, depth + 1)
+      : false;
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex system prompt: rollout read failed");
+    return false;
+  }
+}
+
 export function readLatestCodexTokenTotals(
   threadId: string,
   depth = 0,

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.23.2";
+export const NEGOTIUM_VERSION = "0.23.4";

package/dist/types/packages/core/src/agents/claude-notices.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Non-fatal Claude Agent SDK notices → user-visible status lines.
+ *
+ * Fatality is decided only by the terminal `result` message or a CLI exit
+ * (see claude-provider.ts); nothing here may end a turn. The SDK adds and
+ * renames system subtypes often, so the handled subtypes are keyed by the
+ * SDK's own types: a rename or removal fails `tsc` on upgrade, while a
+ * subtype this table does not know is only debug-logged at runtime.
+ */
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * Status text for a non-terminal SDK message, or undefined when it should not
+ * be shown. Never throws and never classifies anything as an error.
+ */
+export declare function claudeNoticeStatus(message: SDKMessage): string | undefined;

package/dist/types/packages/core/src/agents/codex-provider.d.ts

@@ -6,6 +6,12 @@ type CodexEventUsage = {
     cached_input_tokens?: number;
     cache_write_input_tokens?: number;
 };
+/**
+ * One short status line from a free-form Codex notice. Codex sends prose with
+ * no stable code, so only the shape is used: its first sentence, labeled as
+ * Codex's. The full text stays in the log.
+ */
+export declare function codexNoticeStatus(message: string): string;
 /**
  * Some Codex CLI builds expose the thread-lifetime counter on turn.completed
  * despite the SDK declaring turn-local usage. Only subtract a rollout baseline

package/dist/types/packages/core/src/agents/rollout/codex.d.ts

@@ -76,6 +76,18 @@ export declare function extractLatestCodexTokenTotals(jsonl: string): CodexToken
 export declare function readLatestCodexContextUsage(threadId: string): CodexContextUsage | undefined;
 /** `forked_from_id` from a rollout's leading session_meta line, if any. */
 export declare function extractCodexForkedFromId(jsonl: string): string | undefined;
+/**
+ * Text of the latest user turn that carried negotium's `[System Instructions]`
+ * preamble. Codex has no system-prompt option, so the provider inlines it into
+ * the user prompt; this reports what the resumed thread already holds.
+ */
+export declare function extractLatestCodexSystemInstructionsTurn(jsonl: string): string | undefined;
+/**
+ * Whether the thread's history already ends its instruction trail with exactly
+ * `systemPrompt`. Synthesized rollouts (agent switch, fork fallback) carry no
+ * instructions, and a changed prompt must be re-sent, so both report false.
+ */
+export declare function codexThreadHasSystemPrompt(threadId: string, systemPrompt: string, depth?: number): boolean;
 export declare function readLatestCodexTokenTotals(threadId: string, depth?: number): CodexTokenTotals | undefined;
 /**
  * Old and metadata-free Codex rollouts resume as native multi-agent v1 even

package/dist/types/packages/core/src/version.d.ts

@@ -1 +1 @@
-export declare const NEGOTIUM_VERSION = "0.23.2";
+export declare const NEGOTIUM_VERSION = "0.23.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "negotium",
-  "version": "0.23.2",
+  "version": "0.23.4",
   "type": "module",
   "description": "Install the Negotium multi-agent runtime and CLI with one package",
   "license": "Apache-2.0",