@sema-agent/core 5.9.0 → 5.11.0

package/dist/brain/openai.js

@@ -481,9 +481,17 @@ export function createOpenAIBrain(config = {}) {
                             finalContent.push({ type: "text", text: textFace });
                         const toolCalls = [];
                         const malformed = [];
+                        const unnamed = [];
+                        let emptyPlaceholders = 0;
                         for (const acc of [...toolAccum.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1])) {
-                            if (!acc.name)
+                            if (!acc.name) {
+                                if (!acc.id && acc.args === "") {
+                                    emptyPlaceholders++;
+                                    continue;
+                                }
+                                unnamed.push(`id="${acc.id || "?"}"(${acc.args.slice(0, 200)})`);
                                 continue;
+                            }
                             const tc = closeToolCallAccum(acc);
                             if (tc) {
                                 toolCalls.push(tc);
@@ -508,16 +516,35 @@ export function createOpenAIBrain(config = {}) {
                                 }
                             }
                         }
-                        const toolError = malformed.length > 0
-                            ? `tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"): ${malformed.join("; ")}`
-                            : undefined;
+                        const emptySlots = `<empty slot>${emptyPlaceholders > 1 ? ` ×${emptyPlaceholders}` : ""}`;
+                        const sawRealAction = toolCalls.length > 0 || malformed.length > 0 || unnamed.length > 0;
+                        if (emptyPlaceholders > 0 && sawRealAction) {
+                            unnamed.push(emptySlots);
+                        }
+                        else if (!sawRealAction && finishReason === "tool_calls") {
+                            unnamed.push(emptyPlaceholders > 0 ? emptySlots : "<no tool_call delta arrived on the stream>");
+                        }
+                        const toolErrorParts = [];
+                        if (malformed.length > 0) {
+                            toolErrorParts.push(`tool call argument(s) not valid JSON (likely truncated, finish_reason="${finishReason ?? "?"}"${sentMaxTokens !== undefined ? `; request output cap in effect: ${sentMaxTokens} tokens — a cut mid-arguments commonly means the cap was hit` : ""}): ${malformed.join("; ")}`);
+                        }
+                        if (unnamed.length > 0) {
+                            toolErrorParts.push(`tool call(s) arrived with no tool name and cannot be executed (finish_reason="${finishReason ?? "?"}"): ${unnamed.join("; ")}`);
+                        }
+                        const toolError = toolErrorParts.length > 0 ? toolErrorParts.join(" | ") : undefined;
                         const noUsableContent = toolCalls.length === 0 && !accumText.trim();
-                        if (toolError !== undefined) {
+                        if (malformed.length > 0) {
                             finalContent.push({
                                 type: "text",
                                 text: `\n[note: ${malformed.length} tool call(s) were truncated (finish_reason="${finishReason ?? "?"}") and dropped — re-issue them next turn: ${malformed.join("; ")}]`,
                             });
                         }
+                        if (unnamed.length > 0) {
+                            finalContent.push({
+                                type: "text",
+                                text: `\n[note: ${unnamed.length} tool call(s) arrived with no tool name and were dropped — re-issue them next turn with an explicit tool name: ${unnamed.join("; ")}]`,
+                            });
+                        }
                         if (malformedFrames > 0) {
                             finalContent.push({
                                 type: "text",

package/dist/core/a2a.js

@@ -23,7 +23,7 @@ const A2A_CARD_DESCRIPTION_MAX_CHARS = 240;
 const A2A_ID_MAX_CHARS = 160;
 const A2A_RESULT_BODY_MAX_CHARS = 100_000;
 const A2A_ERROR_TEXT_MAX_CHARS = 240;
-const A2A_RESULT_FENCE_REASON = "the peer is an autonomous agent, so its output is worker text, not tool data";
+const A2A_RESULT_FENCE_REASON = "the peer is an agent acting on its own, so its output is worker text, not tool data";
 const A2A_CARD_PATHS = ["/.well-known/agent-card.json", "/.well-known/agent.json"];
 const A2A_PROTOCOL_VERSION = "1.0";
 const A2A_JSONRPC_TRANSPORT = "JSONRPC";

package/dist/core/background-agent-store.d.ts

@@ -40,13 +40,14 @@ export interface BackgroundAgentRecord {
     errorCode?: string;
     errorRetryable?: boolean;
     errorKind?: string;
+    errorRetryAfterMs?: number;
     resultIsPartial?: boolean;
     recentSteps?: SubagentStep[];
     editedFiles?: SubagentEditedFile[];
     usage?: BackgroundAgentUsage;
     rev: number;
 }
-export declare const REVIVED_ROW_CLEARED_FIELDS: readonly ["settledAt", "stoppedBy", "completionId", "finalOutput", "finalOutputFull", "error", "errorCode", "errorRetryable", "errorKind", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"];
+export declare const REVIVED_ROW_CLEARED_FIELDS: readonly ["settledAt", "stoppedBy", "completionId", "finalOutput", "finalOutputFull", "error", "errorCode", "errorRetryable", "errorKind", "errorRetryAfterMs", "resultIsPartial", "summary", "recentSteps", "editedFiles", "usage"];
 export declare function clearRevivedRowTerminalPayload(record: BackgroundAgentRecord): void;
 export interface BackgroundAgentRowSummary {
     handle: string;

package/dist/core/background-agent-store.js

@@ -9,6 +9,7 @@ export const REVIVED_ROW_CLEARED_FIELDS = [
     "errorCode",
     "errorRetryable",
     "errorKind",
+    "errorRetryAfterMs",
     "resultIsPartial",
     "summary",
     "recentSteps",

package/dist/core/checkpoint-store.d.ts

@@ -24,6 +24,7 @@ export interface RiskDescriptor {
         shell?: boolean;
     };
     toolName: string;
+    shellGateDoctrine?: "classify" | "always";
     summary?: string;
     touchedPaths?: string[];
 }
@@ -39,6 +40,7 @@ export declare function buildRiskDescriptor(input: {
     args: unknown;
     safety?: SafetyAxis;
     shellGated?: boolean;
+    shellGateDoctrine?: "classify" | "always";
 }): RiskDescriptor;
 export type CheckpointGate = {
     kind: "human";

package/dist/core/checkpoint-store.js

@@ -115,6 +115,7 @@ export function buildRiskDescriptor(input) {
             severity: riskSeverity(axes),
             axes,
             toolName,
+            ...(input.shellGated && input.shellGateDoctrine !== undefined ? { shellGateDoctrine: input.shellGateDoctrine } : {}),
             ...(summary !== undefined ? { summary } : {}),
             ...(touchedPaths !== undefined ? { touchedPaths } : {}),
         };

package/dist/core/memory-recall.js

@@ -30,6 +30,11 @@ export const RECALL_CAVEAT = "These notes were recalled as relevant, but they ar
     "- If the user is about to act on your recommendation (not just asking about history), verify first.\n" +
     "- If a note names a file, check the file exists; if it names a function or symbol, grep for it; if it names a flag or value, read the current source.\n" +
     "- Memory is a snapshot from when it was written, not a live view — prefer `git log` or reading the code over recalling the snapshot.";
+function isNewerNote(candidate, incumbent) {
+    if (candidate.timestampMissing || incumbent.timestampMissing)
+        return false;
+    return candidate.mtimeMs > incumbent.mtimeMs;
+}
 export function resolveLinkedIds(headers, selected, max) {
     if (max <= 0 || selected.length === 0)
         return [];
@@ -38,7 +43,7 @@ export function resolveLinkedIds(headers, selected, max) {
         if (!h.name)
             continue;
         const prev = byName.get(h.name);
-        if (!prev || h.mtimeMs > prev.mtimeMs)
+        if (!prev || isNewerNote(h, prev))
             byName.set(h.name, h);
     }
     const selectedIds = new Set(selected.map((r) => r.id));
@@ -100,8 +105,8 @@ export function validateSelectedIds(headers, ids, max) {
 export function composeSelectiveBody(manifestText, selected, nowMs, linked = [], recallable = true) {
     const renderNote = (r, label) => {
         const ageMs = nowMs - r.mtimeMs;
-        const verify = ageMs > ONE_DAY_MS ? " — verify it's still current" : "";
-        const stale = ` (written ${formatMemoryAge(ageMs)}${verify})`;
+        const verify = r.timestampMissing || ageMs > ONE_DAY_MS ? " — verify it's still current" : "";
+        const stale = r.timestampMissing ? ` (write time unknown${verify})` : ` (written ${formatMemoryAge(ageMs)}${verify})`;
         const prefix = label ? `${sanitizeUntrustedText(label, ["user_memory"])} ` : "";
         return `- ${prefix}${sanitizeUntrustedText(r.text, ["user_memory"])}${stale}`;
     };

package/dist/core/memory.d.ts

@@ -40,6 +40,7 @@ export interface MemoryNoteHeader {
     id: string;
     description: string;
     mtimeMs: number;
+    timestampMissing?: true;
     name?: string;
     type?: string;
     consolidationGenerated?: boolean;
@@ -84,6 +85,10 @@ export declare class InMemoryMemoryStore implements MemoryStore {
 export declare function expandLexicalTerms(term: string): string[];
 export declare function lexicalSearchMatch(query: string, text: string): boolean;
 export declare function firstSentence(text: string): string;
+export declare function parseNoteTimestamp(ts: unknown): {
+    mtimeMs: number;
+    timestampMissing?: true;
+};
 export interface NormalizedMemorySpec {
     scopes: string[];
     writeScope: string | null;

package/dist/core/memory.js

@@ -268,7 +268,7 @@ export class InMemoryMemoryStore {
         return entries.map((e) => ({
             id: e.id,
             description: e.description ?? firstSentence(e.text),
-            mtimeMs: mtimeMsOf(e.ts),
+            ...parseNoteTimestamp(e.ts),
             ...(e.name ? { name: e.name } : {}),
             ...(e.type ? { type: e.type } : {}),
             ...(e.consolidationGenerated ? { consolidationGenerated: true } : {}),
@@ -291,7 +291,7 @@ export class InMemoryMemoryStore {
             id: e.id,
             text: e.text,
             description: e.description ?? firstSentence(e.text),
-            mtimeMs: mtimeMsOf(e.ts),
+            ...parseNoteTimestamp(e.ts),
             ...(e.name ? { name: e.name } : {}),
             ...(e.type ? { type: e.type } : {}),
             ...(e.consolidationGenerated ? { consolidationGenerated: true } : {}),
@@ -347,9 +347,11 @@ export function firstSentence(text) {
     const cut = dot >= 0 && dot < 160 ? dot + 1 : Math.min(t.length, 120);
     return t.slice(0, cut).trim();
 }
-function mtimeMsOf(ts) {
+export function parseNoteTimestamp(ts) {
+    if (typeof ts !== "string" || ts.trim() === "")
+        return { mtimeMs: 0, timestampMissing: true };
     const ms = Date.parse(`${ts.replace(" ", "T")}:00Z`);
-    return Number.isFinite(ms) ? ms : 0;
+    return Number.isFinite(ms) ? { mtimeMs: ms } : { mtimeMs: 0, timestampMissing: true };
 }
 export function normalizeMemorySpec(input) {
     if (!input)

package/dist/core/runner/assemble-result.js

@@ -86,6 +86,15 @@ export function assembleResult(spec, sessionId, final, stats, flags) {
         status = "failed";
         errorCode = "suspend.loop";
         errorMessage = "task suspended too many times (resume/restart loop) — exceeded the suspend limit";
+        const gates = stats.humanReview?.gates ?? [];
+        if (gates.length > 0 && gates.every((g) => g.decision === "allow")) {
+            errorMessage +=
+                `. Diagnosis: all ${gates.length} recorded gate decision(s) on this run were ALLOW — a gate that keeps ` +
+                    `asking combined with an approver that keeps approving consumes the suspend allowance on legitimate ` +
+                    `work. Remedies: answer asks at a LIVE onAsk (a synchronous allow parks nothing and consumes no ` +
+                    `suspend), keep provably-benign commands inside the read boundary so the classifier auto-allows them, ` +
+                    `or raise maxSuspends for genuinely approval-heavy tasks.`;
+        }
     }
     else if (flags.threw) {
         status = "failed";

package/dist/core/runner/prepare-task.d.ts

@@ -9,6 +9,7 @@ import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
 import type { OnAsk, ToolPolicy } from "../tool-policy.js";
 import { type ActiveSkillFrame } from "./active-skill-scope.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
+import { type RecoveredOrphan } from "../session-reconcile.js";
 import { CacheBreakDetector, type ToolFingerprintInput } from "../cache-break-detector.js";
 import { type BrainCallGuardrailRef } from "../../brain/timeout.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
@@ -18,7 +19,7 @@ import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
 import { type WorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import type { Runner } from "./runtask.js";
-import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
+import { type CheckpointGate, type CheckpointState, type CheckpointStore, type CheckpointToken, type ResourceLedger, type PlatformLimitReason, type ResourceLimitReason } from "../checkpoint-store.js";
 import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
 import type { NestedUsageAccum, RunnerDeps, TaskEvent, TaskLimits, TaskResult, TaskSpec, ToolActivity, ToolEffect } from "../types.js";
 import type { RepairBundle } from "../../agents/repair-loop.js";
@@ -42,6 +43,11 @@ export declare function checkpointScopeOf(spec: {
     };
     principal?: string;
 }): string;
+export declare function resolveCheckpointStore(spec: {
+    checkpointStore?: CheckpointStore | null;
+}, deps: {
+    checkpointStore?: CheckpointStore;
+}): CheckpointStore | undefined;
 export interface Prepared {
     harness: AgentHarness;
     session: StoredSession;
@@ -115,6 +121,7 @@ export interface Prepared {
     } | undefined;
     activeTools: Set<string>;
     deferredToolNames?: ReadonlySet<string>;
+    toolMaterializeStatic: boolean;
     memoryEngineSession?: {
         engine: MemoryEngine;
         handle: MemorySessionHandle;
@@ -128,6 +135,9 @@ export interface Prepared {
         scope?: string;
         restoreMode?: "snapshot" | "park_only";
     };
+    suspendProgressRef: {
+        executedApproved: boolean;
+    };
     reviewRef: {
         token?: CheckpointToken;
         gate?: CheckpointGate;
@@ -187,6 +197,7 @@ export interface Prepared {
     now: () => number;
     tools: AgentTool[];
     toolEffects: Map<string, ToolEffect>;
+    wakeRecovered: RecoveredOrphan[];
     promptOverheadTokens: number;
     readTaskFile?: (path: string) => Promise<string | null>;
     recentlyReadFiles?: () => string[];