@sema-agent/core 2.1.0 → 2.3.0

package/dist/core/task-registry.js

@@ -6,10 +6,10 @@ import { canAccessAgentRecord, } from "./background-agent-store.js";
 import { delimitUntrusted } from "./untrusted-text.js";
 import { registerMonitorLane, pollMonitorLane, stopMonitorLane } from "./task-registry-monitor.js";
 import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task-registry-workflow.js";
-import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, droppedGapNote, alreadyTerminalStopNote, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
+import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_ALIASES, TASK_STOP_ALIASES, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
-import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
+import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
@@ -24,19 +24,18 @@ const TASK_PREFIX = {
     background_agent: "a",
     monitor: "m",
 };
-function noTask(taskId) {
+function noTask(taskId, runningAgents) {
     return {
-        content: JSON.stringify({ error: "task not found" }),
+        content: `No task found with ID: ${taskId}${runningAgents ? notFoundRunningAgentsTail(runningAgents) : ""}`,
         details: { task_id: taskId, type: "unknown", status: "not_found", retrieval_status: "not_ready", error: "not_found" },
         isError: true,
     };
 }
 function noTaskForStop(taskId, enrich) {
     let content = `No task found with ID: ${taskId}`;
-    if (enrich?.suggestion !== undefined)
+    if (enrich.suggestion !== undefined)
         content += `. Did you mean: ${enrich.suggestion}?`;
-    if (enrich?.runningAgents !== undefined && enrich.runningAgents.length > 0)
-        content += `. Running background agents: ${enrich.runningAgents.join(", ")}`;
+    content += notFoundRunningAgentsTail(enrich.runningAgents);
     return {
         content,
         details: { task_id: taskId, type: "unknown", status: "not_found", retrieval_status: "not_ready", error: "not_found" },
@@ -152,8 +151,8 @@ export class TaskRegistry {
     runningBackgroundAgentLabels(access) {
         return runningBackgroundAgentLabelsLane(this.core, access);
     }
-    async pollBackgroundAgent(handle, deadline, signal) {
-        return pollBackgroundAgentLane(handle, deadline, signal);
+    async pollBackgroundAgent(handle, deadline, signal, oneShot, toolResultStore, sessionId) {
+        return pollBackgroundAgentLane(handle, deadline, signal, oneShot, toolResultStore, sessionId);
     }
     async stopBackgroundAgent(handle) {
         return stopBackgroundAgentLane(this.core, handle);
@@ -387,7 +386,7 @@ export class TaskRegistry {
                     ...(handle.outputFile !== undefined ? { output_file: handle.outputFile } : {}),
                     status: "killed",
                     stoppedBy: handle.stoppedBy,
-                    summary: `${(handle.description ?? "background command").slice(0, 200)} — killed before completion (${clause(handle.stoppedBy)})${killFailed ? ` — kill attempt reported ${kill.ok ? "" : kill.error.code}: the process may still be terminating; the environment teardown retries` : ""}${bashMirrorGapNote(handle)}`,
+                    summary: `${terminalTaskSummary("bash", (handle.description ?? "background command").slice(0, 200), "killed")} — killed before completion (${clause(handle.stoppedBy)})${killFailed ? ` — kill attempt reported ${kill.ok ? "" : kill.error.code}: the process may still be terminating; the environment teardown retries` : ""}${bashMirrorGapNote(handle)}`,
                     ...(resultText.length > 0 ? { result: resultText, partial: true } : {}),
                     ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
                 }));
@@ -413,7 +412,7 @@ export class TaskRegistry {
                     ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
                     status: "killed",
                     stoppedBy: handle.stoppedBy,
-                    summary: `${(handle.description ?? "monitor").slice(0, 200)} — killed before completion (${clause(handle.stoppedBy)}); watch ended.${killFailed ? ` Kill attempt reported ${kill.ok ? "" : kill.error.code}: the process may still be terminating; the environment teardown retries.` : ""}`,
+                    summary: `${terminalTaskSummary("monitor", (handle.description ?? "monitor").slice(0, 200), "killed")} — killed before completion (${clause(handle.stoppedBy)}); watch ended.${killFailed ? ` Kill attempt reported ${kill.ok ? "" : kill.error.code}: the process may still be terminating; the environment teardown retries.` : ""}`,
                     ...(lastLines.length > 0 ? { lines: lastLines, result: lastLines.join("\n"), partial: true } : {}),
                     ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
                 }));
@@ -624,7 +623,7 @@ export class TaskRegistry {
                         ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
                         ...(handle.outputFile !== undefined ? { output_file: handle.outputFile } : {}),
                         status: "failed",
-                        summary: `${(handle.description ?? "background command").slice(0, 200)} — lost its background process (${r.error.message}); no further output will arrive.${bashMirrorGapNote(handle)}`,
+                        summary: `${terminalTaskSummary("bash", (handle.description ?? "background command").slice(0, 200), "failed")} — lost its background process (${r.error.message}); no further output will arrive.${bashMirrorGapNote(handle)}`,
                         ...(lostResult.length > 0 ? { result: lostResult } : {}),
                         ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
                     }));
@@ -666,14 +665,12 @@ export class TaskRegistry {
                         ...(handle.status === "killed" && handle.stoppedBy !== undefined ? { stoppedBy: handle.stoppedBy } : {}),
                         ...(r.value.status === "exited" && r.value.exitCode !== undefined ? { exitCode: r.value.exitCode } : {}),
                         summary: (r.value.status === "exited"
-                            ? r.value.exitCode === 0
-                                ? `Background command "${desc}" completed (exit code 0)`
-                                : `Background command "${desc}" failed (exit code ${r.value.exitCode})`
+                            ? terminalTaskSummary("bash", desc, r.value.exitCode === 0 ? "completed" : "failed", r.value.exitCode)
                             : r.value.timedOut === true
                                 ? r.value.timeoutSec !== undefined
-                                    ? `${desc} — timed out after ${r.value.timeoutSec}s (its own background time budget); the process was killed`
-                                    : `${desc} — timed out (its own background time budget); the process was killed`
-                                : `${desc} — ${r.value.status}`) +
+                                    ? `${terminalTaskSummary("bash", desc, "killed")} — timed out after ${r.value.timeoutSec}s (its own background time budget); the process was killed`
+                                    : `${terminalTaskSummary("bash", desc, "killed")} — timed out (its own background time budget); the process was killed`
+                                : `${terminalTaskSummary("bash", desc, handle.status === "completed" ? "completed" : handle.status === "killed" ? "killed" : "failed")} — ${r.value.status}`) +
                             bashMirrorGapNote(handle) +
                             droppedGapNote(spool),
                         ...(resultText.length > 0 ? { result: resultText } : {}),
@@ -698,7 +695,7 @@ export class TaskRegistry {
                     ...(handle.toolUseId !== undefined ? { toolUseId: handle.toolUseId } : {}),
                     ...(handle.outputFile !== undefined ? { output_file: handle.outputFile } : {}),
                     status: "failed",
-                    summary: `${(handle.description ?? "background command").slice(0, 200)} — lost its background process (poll failed: ${e instanceof Error ? e.message : String(e)}); no further output will arrive.${bashMirrorGapNote(handle)}`,
+                    summary: `${terminalTaskSummary("bash", (handle.description ?? "background command").slice(0, 200), "failed")} — lost its background process (poll failed: ${e instanceof Error ? e.message : String(e)}); no further output will arrive.${bashMirrorGapNote(handle)}`,
                     ...(crashedResult.length > 0 ? { result: crashedResult } : {}),
                     ...(handle.completionId !== undefined ? { completionId: handle.completionId } : {}),
                 }));
@@ -749,9 +746,9 @@ export class TaskRegistry {
         const handle = this.resolveInternal(taskId, access);
         if (handle) {
             if (handle.type === "background_bash")
-                return this.pollBackgroundBash(handle, taskId, opts.filter, deadline, opts.signal);
+                return this.pollBackgroundBash(handle, taskId, access, opts.filter, deadline, opts.signal);
             if (handle.type === "background_agent")
-                return this.pollBackgroundAgent(handle, deadline, opts.signal);
+                return this.pollBackgroundAgent(handle, deadline, opts.signal, opts.oneShot, opts.toolResultStore, access.sessionId);
             if (handle.type === "monitor")
                 return this.pollMonitor(handle, opts.filter, deadline, opts.signal);
             return this.pollWorkflow(handle, access, deadline, opts.signal);
@@ -803,7 +800,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
                 await sleepPollStep(deadline, opts.signal);
             }
         }
-        return noTask(taskId);
+        return noTask(taskId, runningAgentFooterLane(this.core, access));
     }
     async stopTask(id, access, opts = {}) {
         const taskId = id.trim();
@@ -876,7 +873,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
         }
         return noTaskForStop(taskId, {
             ...(byName.suggestion !== undefined ? { suggestion: byName.suggestion } : {}),
-            runningAgents: this.runningBackgroundAgentLabels(access),
+            runningAgents: runningAgentFooterLane(this.core, access),
         });
     }
     deliverConfirmTimeoutMs = 10_000;
@@ -974,7 +971,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             return undefined;
         return handle;
     }
-    async pollBackgroundBash(handle, requestedId, filter, deadline, signal) {
+    async pollBackgroundBash(handle, requestedId, access, filter, deadline, signal) {
         let rx;
         if (filter !== undefined) {
             try {
@@ -989,7 +986,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             }
         }
         if (!hasBackgroundShell(handle.env))
-            return noTask(requestedId);
+            return noTask(requestedId, runningAgentFooterLane(this.core, access));
         if (handle.spool !== undefined) {
             while (handle.status === "running" && deadline !== undefined && Date.now() < deadline && !signal?.aborted) {
                 await sleepPollStep(deadline, signal);
@@ -1043,7 +1040,7 @@ The durable record is still marked running (last update ${new Date(row.updatedAt
             const r = await handle.env.pollBackground(handle.shellId);
             if (!r.ok) {
                 if (r.error.code === "not_found")
-                    return noTask(requestedId);
+                    return noTask(requestedId, runningAgentFooterLane(this.core, access));
                 const retrieval_status = r.error.code === "timeout" ? "timeout" : "not_ready";
                 const salvaged = stdout.length > 0 || stderr.length > 0
                     ? `\n--- output accumulated before the error ---\n${clipTaskOutput(stdout, handle.outputFile)}${stderr ? `\n--- stderr ---\n${clipTaskOutput(stderr, handle.outputFile)}` : ""}`
@@ -1216,6 +1213,8 @@ export function createTaskOutputTool(opts) {
                 block: args.block !== false,
                 timeoutMs: effectiveTimeoutMs,
                 signal: ctx.signal,
+                oneShot: opts.oneShot,
+                toolResultStore: opts.toolResultStore,
             });
             const { type: taskType, ...rest } = r.details;
             return {

package/dist/core/tools.d.ts

@@ -6,4 +6,6 @@ export declare function errorResult(text: string, details?: unknown): {
     isError: true;
     details?: unknown;
 };
+export declare function isDefineToolProduct(x: unknown): x is AgentTool;
+export declare function stampDefineToolBrand<T extends object>(tool: T): T;
 export declare function defineTool<TParams extends TSchema = TSchema>(spec: ToolSpec<TParams>): AgentTool<TParams>;

package/dist/core/tools.js

@@ -25,6 +25,14 @@ function isEmptyToolContent(content) {
 export function errorResult(text, details) {
     return details === undefined ? { content: text, isError: true } : { content: text, isError: true, details };
 }
+const DEFINE_TOOL_BRAND = Symbol("sema.core.defineTool.product");
+export function isDefineToolProduct(x) {
+    return typeof x === "object" && x !== null && x[DEFINE_TOOL_BRAND] === true;
+}
+export function stampDefineToolBrand(tool) {
+    Object.defineProperty(tool, DEFINE_TOOL_BRAND, { value: true, enumerable: false });
+    return tool;
+}
 export function defineTool(spec) {
     const executionMode = spec.executionMode ?? (spec.effect === "read" ? "parallel" : "sequential");
     const tool = {
@@ -72,5 +80,6 @@ export function defineTool(spec) {
             ...(spec.aliases && spec.aliases.length > 0 ? { aliases: spec.aliases } : {}),
         });
     }
+    stampDefineToolBrand(tool);
     return tool;
 }

package/dist/core/types.d.ts

@@ -92,6 +92,7 @@ export interface ToolExecuteContext {
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
+    oneShot?: boolean;
     clientContext?: TaskSpec["clientContext"];
     excludeTools?: readonly string[];
     deferTools?: readonly string[];
@@ -344,6 +345,7 @@ export interface TaskSpec {
     attachments?: {
         todoReminder?: true;
         todoReminderMode?: "baseline" | "off";
+        toolSearchReminder?: true;
         changedFiles?: true | {
             maxFiles?: number;
         };
@@ -534,7 +536,7 @@ export type TaskEvent = ({
     phaseDurations?: import("./auto-compaction.js").CompactionPhaseDurations;
 } | ({
     type: "steering_injected";
-    source: "deadline_nudge" | "finalize" | "todo_reminder" | "task_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
+    source: "deadline_nudge" | "finalize" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
     preview: string;
 } & TaskEventIdentity) | ({
     type: "diagnostics";

package/dist/core/workflow-journal-store.d.ts

@@ -26,8 +26,24 @@ export declare function oversizeJournalResult(serialized: string): boolean;
 export declare function callKeyOrdinal(callKey: string): number;
 export declare const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
 export declare function journalOversizeTombstone(result: TaskResult, bytes: number): TaskResult;
+export declare const IN_MEMORY_RESUME_CLAIM_TTL_MS: number;
 export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStore {
     private readonly runs;
+    private readonly resumeClaims;
+    private claimsForScope;
+    resumeClaim(input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): Promise<{
+        granted: boolean;
+        holder?: string;
+    }>;
+    releaseResumeClaim(input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): Promise<void>;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
 }

package/dist/core/workflow-journal-store.js

@@ -29,8 +29,36 @@ function snapshot(entry) {
         return JSON.parse(JSON.stringify(entry));
     }
 }
+export const IN_MEMORY_RESUME_CLAIM_TTL_MS = 60 * 60 * 1000;
 export class InMemoryWorkflowJournalStore {
     runs = new Map();
+    resumeClaims = new Map();
+    claimsForScope(scope) {
+        let m = this.resumeClaims.get(scope);
+        if (m === undefined) {
+            m = new Map();
+            this.resumeClaims.set(scope, m);
+        }
+        return m;
+    }
+    async resumeClaim(input) {
+        const table = this.claimsForScope(input.scope);
+        const now = Date.now();
+        const existing = table.get(input.sourceRunId);
+        if (existing !== undefined && existing.expiresAt > now && existing.holder !== input.newRunId) {
+            return { granted: false, holder: existing.holder };
+        }
+        table.set(input.sourceRunId, { holder: input.newRunId, expiresAt: now + IN_MEMORY_RESUME_CLAIM_TTL_MS });
+        return { granted: true };
+    }
+    async releaseResumeClaim(input) {
+        const table = this.resumeClaims.get(input.scope);
+        if (table === undefined)
+            return;
+        const existing = table.get(input.sourceRunId);
+        if (existing !== undefined && existing.holder === input.newRunId)
+            table.delete(input.sourceRunId);
+    }
     async load(runId, scope) {
         const rec = this.runs.get(runId);
         if (!rec || rec.scope !== scope)

package/dist/engine/session/memory-repo.js

@@ -5,6 +5,11 @@ import { createSessionId, createTimestamp, getEntriesToFork, toSession } from ".
 export class InMemorySessionRepo {
     sessions = new Map();
     async create(options = {}) {
+        if (options.id !== undefined) {
+            const existing = this.sessions.get(options.id);
+            if (existing)
+                return existing;
+        }
         const metadata = {
             id: options.id ?? createSessionId(),
             createdAt: createTimestamp(),

package/dist/index.d.ts

@@ -113,7 +113,7 @@ export { encodeSurfacedKey, buildManifestText, validateSelectedIds, composeSelec
 export { runMemoryConsolidation, CONSOLIDATION_SYSTEM_PROMPT, DEFAULT_CONSOLIDATION_BAND, DEFAULT_CONSOLIDATION_SEARCH_LIMIT, DEFAULT_CONSOLIDATION_MAX_NOTES, DEFAULT_CONSOLIDATION_TIMEOUT_SEC, normalizeForExactMatch, type ConsolidationParams, type ConsolidationStats, type ConsolidationNote, type ConsolidationLLM, } from "./core/runner/memory-consolidation.js";
 export { consolidateScope, advanceCursorAfterInline, type ConsolidateScopeDeps, type ConsolidateScopeOptions, } from "./core/consolidate-scope.js";
 export { DEFAULT_COMPACTION_INSTRUCTIONS } from "./core/auto-compaction.js";
-export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, AUTONOMY_SELF_AUDIT, ANTI_VERBOSITY, TOOL_PARAM_JSON, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, type EnvironmentFacts, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, type PromptBlock, analyzePromptCacheFriendliness, assertPromptCacheFriendly, type PromptProvider, type StablePromptContext, type PromptCacheReport, type PromptTextDeclaration, } from "./prompts/default.js";
+export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, type EnvironmentFacts, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, type PromptBlock, analyzePromptCacheFriendliness, assertPromptCacheFriendly, type PromptProvider, type StablePromptContext, type PromptCacheReport, type PromptTextDeclaration, } from "./prompts/default.js";
 export { SUPERVISOR_PROMPT, ORCHESTRATION_GUIDANCE, ORCHESTRATION_AWARENESS, GOAL_COMPLETION_GUIDANCE } from "./prompts/supervisor.js";
 export { compose, validatePack } from "./prompt-assembly/composer.js";
 export { SEMA_DEFAULT_PACK } from "./prompt-assembly/packs/sema-default.js";

package/dist/index.js

@@ -101,7 +101,7 @@ export { encodeSurfacedKey, buildManifestText, validateSelectedIds, composeSelec
 export { runMemoryConsolidation, CONSOLIDATION_SYSTEM_PROMPT, DEFAULT_CONSOLIDATION_BAND, DEFAULT_CONSOLIDATION_SEARCH_LIMIT, DEFAULT_CONSOLIDATION_MAX_NOTES, DEFAULT_CONSOLIDATION_TIMEOUT_SEC, normalizeForExactMatch, } from "./core/runner/memory-consolidation.js";
 export { consolidateScope, advanceCursorAfterInline, } from "./core/consolidate-scope.js";
 export { DEFAULT_COMPACTION_INSTRUCTIONS } from "./core/auto-compaction.js";
-export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, AUTONOMY_SELF_AUDIT, ANTI_VERBOSITY, TOOL_PARAM_JSON, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, analyzePromptCacheFriendliness, assertPromptCacheFriendly, } from "./prompts/default.js";
+export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, analyzePromptCacheFriendliness, assertPromptCacheFriendly, } from "./prompts/default.js";
 export { SUPERVISOR_PROMPT, ORCHESTRATION_GUIDANCE, ORCHESTRATION_AWARENESS, GOAL_COMPLETION_GUIDANCE } from "./prompts/supervisor.js";
 export { compose, validatePack } from "./prompt-assembly/composer.js";
 export { SEMA_DEFAULT_PACK } from "./prompt-assembly/packs/sema-default.js";

package/dist/orchestration/workflow-size-guideline.d.ts

@@ -1,7 +1,12 @@
 export type WorkflowSizeGuideline = "small" | "medium" | "large" | "unrestricted";
 export declare const WORKFLOW_SIZE_GUIDELINES: readonly WorkflowSizeGuideline[];
+export declare const WORKFLOW_SIZE_GUIDELINE_DEFAULT: WorkflowSizeGuideline;
 export declare const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS: Readonly<Record<"small" | "medium" | "large", number>>;
-export declare function normalizeWorkflowSizeGuideline(value: unknown): WorkflowSizeGuideline;
+export declare function normalizeWorkflowSizeGuideline(value: unknown): WorkflowSizeGuideline | undefined;
+export declare function resolveWorkflowSizeGuideline(value: unknown): {
+    size: WorkflowSizeGuideline;
+    isDefault: boolean;
+};
 export declare function workflowSizeGuidelineAgentCap(g: WorkflowSizeGuideline): number | undefined;
 export declare function describeWorkflowSizeGuideline(g: WorkflowSizeGuideline): string;
 export declare function formatWorkflowSizeGuidelineLabel(g: WorkflowSizeGuideline): string;

package/dist/orchestration/workflow-size-guideline.js

@@ -1,13 +1,16 @@
 export const WORKFLOW_SIZE_GUIDELINES = ["unrestricted", "small", "medium", "large"];
+export const WORKFLOW_SIZE_GUIDELINE_DEFAULT = "medium";
 export const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS = {
     small: 5,
     medium: 15,
     large: 50,
 };
 export function normalizeWorkflowSizeGuideline(value) {
-    if (value === "small" || value === "medium" || value === "large")
-        return value;
-    return "unrestricted";
+    return WORKFLOW_SIZE_GUIDELINES.includes(value) ? value : undefined;
+}
+export function resolveWorkflowSizeGuideline(value) {
+    const configured = normalizeWorkflowSizeGuideline(value);
+    return configured === undefined ? { size: WORKFLOW_SIZE_GUIDELINE_DEFAULT, isDefault: true } : { size: configured, isDefault: false };
 }
 export function workflowSizeGuidelineAgentCap(g) {
     return g === "small" || g === "medium" || g === "large" ? WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS[g] : undefined;
@@ -24,14 +27,21 @@ export function formatWorkflowSizeGuidelineLabel(g) {
     const cap = workflowSizeGuidelineAgentCap(g);
     return cap === undefined ? g : `${g} (aim for <${cap} agents)`;
 }
+function workflowSizeGuidelineSentence(g, isDefault) {
+    const lead = isDefault
+        ? "This session has the default workflow size guideline:"
+        : "A workflow size guideline is configured for this session:";
+    const escape = isDefault ? ' The user can raise or remove it with "Dynamic workflow size" in /config.' : "";
+    return `${lead} ${describeWorkflowSizeGuideline(g)}. ${guidelineNotHardLimit()}${escape}`;
+}
 export function workflowSizeGuidelineSection(value) {
-    const g = normalizeWorkflowSizeGuideline(value);
-    if (g !== "unrestricted")
-        return `\n\nThe user has configured a workflow size guideline in /config: ${describeWorkflowSizeGuideline(g)}. ${guidelineNotHardLimit()}`;
-    return "";
+    const { size, isDefault } = resolveWorkflowSizeGuideline(value);
+    if (size === "unrestricted")
+        return "";
+    return `\n\n${workflowSizeGuidelineSentence(size, isDefault)}`;
 }
 export function workflowSizeGuidelineChangeNotice(g) {
     if (g === "unrestricted")
-        return "The user removed their workflow size guideline in /config — workflow size is unrestricted again.";
-    return `The user changed their workflow size guideline in /config: ${describeWorkflowSizeGuideline(g)}. ${guidelineNotHardLimit()}`;
+        return "Workflow size is now unrestricted — no size guideline applies.";
+    return `The workflow size guideline for this session changed: ${describeWorkflowSizeGuideline(g)}. ${guidelineNotHardLimit()}`;
 }

package/dist/orchestration/workflow.d.ts

@@ -124,9 +124,25 @@ export declare const MAX_WORKFLOW_ITEMS = 4096;
 export declare const WORKFLOW_AGENT_STALL_MS = 180000;
 export declare const WORKFLOW_AGENT_MAX_RETRIES = 5;
 export declare const WORKFLOW_AGENT_THROTTLE_BACKOFF_MS = 45000;
+export declare const WORKFLOW_RESUME_CLAIM_FINALIZE_TIMEOUT_MS = 10000;
 export interface WorkflowTimers {
     setTimeout(fn: () => void, ms: number): unknown;
     clearTimeout(handle: unknown): void;
 }
+export declare const workflowResumeClaimFallback: {
+    acquire(store: WorkflowJournalStore, input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): {
+        granted: boolean;
+        holder?: string;
+    };
+    release(store: WorkflowJournalStore, input: {
+        sourceRunId: string;
+        newRunId: string;
+        scope: string;
+    }): void;
+};
 export declare function startWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): WorkflowHandle<T>;
 export declare function runWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): Promise<RunWorkflowResult<T>>;

package/dist/orchestration/workflow.js

@@ -20,6 +20,7 @@ const MAX_TRANSCRIPT_CHARS = 4000;
 const WORKFLOW_RESULT_MAX = 4000;
 const WORKFLOW_RESULT_FULL_MAX = 200_000;
 const MAX_ACTIVITY = 30;
+const RUNNING_AGENT_PERSIST_EVERY_BEATS = 4;
 function workflowModelLabel(spec) {
     const model = spec.model;
     if (model === undefined)
@@ -132,6 +133,7 @@ export const MAX_WORKFLOW_ITEMS = 4096;
 export const WORKFLOW_AGENT_STALL_MS = 180_000;
 export const WORKFLOW_AGENT_MAX_RETRIES = 5;
 export const WORKFLOW_AGENT_THROTTLE_BACKOFF_MS = 45_000;
+export const WORKFLOW_RESUME_CLAIM_FINALIZE_TIMEOUT_MS = 10_000;
 const REAL_WORKFLOW_TIMERS = {
     setTimeout(fn, ms) {
         const t = setTimeout(fn, ms);
@@ -142,6 +144,21 @@ const REAL_WORKFLOW_TIMERS = {
         clearTimeout(handle);
     },
 };
+async function finalizeWithin(timers, p, fallback) {
+    let handle;
+    try {
+        return await Promise.race([
+            p,
+            new Promise((resolve) => {
+                handle = timers.setTimeout(() => resolve(fallback), WORKFLOW_RESUME_CLAIM_FINALIZE_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        if (handle !== undefined)
+            timers.clearTimeout(handle);
+    }
+}
 function defaultConcurrency() {
     let cores = 4;
     try {
@@ -190,6 +207,33 @@ function createSemaphore(max) {
 function clampRunIdText(raw) {
     return raw.replace(/[^A-Za-z0-9_.:-]/g, "").slice(0, 64);
 }
+const fallbackResumeClaimTables = new WeakMap();
+function fallbackResumeClaimKey(scope, sourceRunId) {
+    return JSON.stringify([scope, sourceRunId]);
+}
+export const workflowResumeClaimFallback = {
+    acquire(store, input) {
+        let table = fallbackResumeClaimTables.get(store);
+        if (table === undefined) {
+            table = new Map();
+            fallbackResumeClaimTables.set(store, table);
+        }
+        const key = fallbackResumeClaimKey(input.scope, input.sourceRunId);
+        const holder = table.get(key);
+        if (holder !== undefined && holder !== input.newRunId)
+            return { granted: false, holder };
+        table.set(key, input.newRunId);
+        return { granted: true };
+    },
+    release(store, input) {
+        const table = fallbackResumeClaimTables.get(store);
+        if (table === undefined)
+            return;
+        const key = fallbackResumeClaimKey(input.scope, input.sourceRunId);
+        if (table.get(key) === input.newRunId)
+            table.delete(key);
+    },
+};
 export function startWorkflow(runner, fn, opts = {}, internals) {
     const alsDepth = currentWorkflowDepth();
     const internalDepth = internals?.workflowDepth;
@@ -550,8 +594,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             throw err;
         }
     };
-    const createActivityCapture = (callKey, label, groupId) => {
+    const createActivityCapture = (callKey, label, groupId, rec) => {
         const tail = [];
+        let beatCount = 0;
         const onActivity = (a) => {
             if (finalized)
                 return;
@@ -571,6 +616,13 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             tail.push(a);
             if (tail.length > MAX_ACTIVITY)
                 tail.shift();
+            if (a.phase === "start")
+                rec.toolCalls = (rec.toolCalls ?? 0) + 1;
+            rec.activity = tail;
+            beatCount += 1;
+            if (beatCount === 1 || beatCount % RUNNING_AGENT_PERSIST_EVERY_BEATS === 0) {
+                void persist("update");
+            }
         };
         return { tail, onActivity };
     };
@@ -718,8 +770,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             if (budgetTotal !== null && spent() >= budgetTotal) {
                 throw new WorkflowBudgetExceededError(spent(), budgetTotal);
             }
-            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId);
             const rec = { label, callKey, ...(groupId !== undefined ? { groupId } : {}), phase, prompt, ...(model !== undefined ? { model } : {}), status: "running", queuedAt: now() };
+            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId, rec);
             run.agents.push(rec);
             if (phaseInstance)
                 agentPhaseOf.set(rec, phaseInstance);
@@ -1031,8 +1083,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             const model = workflowModelLabel(specForIdentity);
             noteDivergence(run.agents.length, "ctx.agentStream results are never replayed");
             diverged = true;
-            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId);
             const rec = { label, callKey, ...(groupId !== undefined ? { groupId } : {}), phase, prompt, ...(model !== undefined ? { model } : {}), status: "running", queuedAt: now() };
+            const { tail: activityTail, onActivity } = createActivityCapture(callKey, label, groupId, rec);
             run.agents.push(rec);
             if (phaseInstance)
                 agentPhaseOf.set(rec, phaseInstance);
@@ -1372,18 +1424,19 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         try {
             const runBody = async () => {
                 if (opts.resumeFromRunId !== undefined && journalStore) {
-                    if (journalStore.resumeClaim) {
-                        const verdict = journalStore.resumeClaim({ sourceRunId: opts.resumeFromRunId, newRunId: runId, scope });
-                        resumeClaim = { sourceRunId: opts.resumeFromRunId, verdict };
-                        const decision = await verdict;
-                        if (!decision.granted) {
-                            const holder = decision.holder !== undefined ? clampRunIdText(decision.holder) : "";
-                            throw new Error(`startWorkflow: resume from "${clampRunIdText(opts.resumeFromRunId)}" was REFUSED — ` +
-                                `another run already holds the resume claim on it${holder ? ` (holder: ${holder})` : " (holder unknown to the store)"}. ` +
-                                "Two concurrent resumes of one source run fork its execution: both replay the same prefix and then " +
-                                "re-run the whole suffix live, duplicating every side effect. Wait for the holder to reach a terminal " +
-                                "state (or stop it) and resume again.");
-                        }
+                    const usingFallback = journalStore.resumeClaim === undefined;
+                    const verdict = usingFallback
+                        ? Promise.resolve(workflowResumeClaimFallback.acquire(journalStore, { sourceRunId: opts.resumeFromRunId, newRunId: runId, scope }))
+                        : journalStore.resumeClaim({ sourceRunId: opts.resumeFromRunId, newRunId: runId, scope });
+                    resumeClaim = { sourceRunId: opts.resumeFromRunId, verdict, fallback: usingFallback };
+                    const decision = await verdict;
+                    if (!decision.granted) {
+                        const holder = decision.holder !== undefined ? clampRunIdText(decision.holder) : "";
+                        throw new Error(`startWorkflow: resume from "${clampRunIdText(opts.resumeFromRunId)}" was REFUSED — ` +
+                            `another run already holds the resume claim on it${holder ? ` (holder: ${holder})` : " (holder unknown to the store)"}. ` +
+                            "Two concurrent resumes of one source run fork its execution: both replay the same prefix and then " +
+                            "re-run the whole suffix live, duplicating every side effect. Wait for the holder to reach a terminal " +
+                            "state (or stop it) and resume again.");
                     }
                     const entries = await journalStore.load(opts.resumeFromRunId, scope);
                     for (const e of entries)
@@ -1485,13 +1538,20 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         finally {
             finalized = true;
             await journalTail.catch(() => undefined);
-            if (resumeClaim !== undefined && journalStore?.releaseResumeClaim) {
-                const granted = await resumeClaim.verdict.then((v) => v.granted, () => false);
+            if (resumeClaim !== undefined) {
+                const granted = await finalizeWithin(timers, resumeClaim.verdict.then((v) => v.granted, () => false), false);
                 if (granted) {
-                    try {
-                        await journalStore.releaseResumeClaim({ sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope });
+                    if (resumeClaim.fallback) {
+                        if (journalStore) {
+                            workflowResumeClaimFallback.release(journalStore, { sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope });
+                        }
                     }
-                    catch {
+                    else if (journalStore?.releaseResumeClaim) {
+                        try {
+                            await finalizeWithin(timers, journalStore.releaseResumeClaim({ sourceRunId: resumeClaim.sourceRunId, newRunId: runId, scope }), undefined);
+                        }
+                        catch {
+                        }
                     }
                 }
             }