@sema-agent/core 5.22.0 → 5.24.0

package/dist/stores/file/workflow-journal-store.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { callKeyOrdinal } from "../../core/workflow-journal-store.js";
 import { AppendLog } from "./fs-atomic.js";
 import { canonicalStoreKey, sanitizePathComponent, writeThenLink } from "./fs-atomic.js";
+import { assertAdoptionBootGate } from "./adoption/marker.js";
 import { oversizeJournalResult } from "../../core/workflow-journal-store.js";
 export { MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult } from "../../core/workflow-journal-store.js";
 export const RESUME_CLAIM_TTL_MS = 60 * 60 * 1000;
@@ -28,6 +29,7 @@ export class FileWorkflowJournalStore {
     }
     constructor(root, fsyncEnabled = true) {
         this.fsyncEnabled = fsyncEnabled;
+        assertAdoptionBootGate(root, "FileWorkflowJournalStore");
         this.dir = join(root, "workflow-journal");
         mkdirSync(this.dir, { recursive: true, mode: 0o700 });
         this.claimsDir = join(this.dir, "claims");

package/dist/stores/file/workflow-run-store.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { assertRetentionPolicy } from "../../core/retention-policy.js";
 import { WorkflowRunStoreError, isTerminalWorkflowStatus, nextWorkflowRunOnUpdate, queryWorkflowRuns, } from "../../core/workflow-run-store.js";
 import { SharedLedgerTable } from "./shared-ledger.js";
+import { assertAdoptionBootGate } from "./adoption/marker.js";
 const runLedgers = new SharedLedgerTable({
     keyOf: (run) => run.id,
     apply: (runs, ev) => {
@@ -21,6 +22,7 @@ export class FileWorkflowRunStore {
         return this.ledger.rows;
     }
     constructor(root, opts = {}) {
+        assertAdoptionBootGate(root, "FileWorkflowRunStore");
         this.fsyncEnabled = opts.fsync !== false;
         this.compactEvery = opts.compactEvery ?? 1000;
         const dir = join(root, "workflow-runs");

package/dist/tools/fs/bash-readonly-classifier.js

@@ -238,11 +238,51 @@ function isGrepClusterFileStdin(tok) {
     }
     return false;
 }
-function isCutSeparatedDelimiterOption(tok) {
-    if (tok.includes("="))
+const SEPARATED_VALUE_OPTIONS = {
+    head: { short: "cn", long: ["bytes", "lines"] },
+    tail: { short: "cns", long: ["bytes", "lines", "sleep-interval", "pid", "max-unchanged-stats"] },
+    cut: { short: "bcdf", long: ["bytes", "characters", "delimiter", "fields", "output-delimiter"] },
+    grep: {
+        ownsValueButNotSkippable: "ef",
+        short: "mABCdD",
+        long: [
+            "max-count",
+            "after-context",
+            "before-context",
+            "context",
+            "devices",
+            "directories",
+            "label",
+            "binary-files",
+            "group-separator",
+            "include",
+            "exclude",
+            "exclude-dir",
+        ],
+    },
+};
+function takesSeparatedValue(name, tok) {
+    const model = SEPARATED_VALUE_OPTIONS[name];
+    if (model === undefined)
         return false;
-    const name = longOptionNameOf(tok);
-    return name !== undefined && (isLongOptionAbbrevOf(name, "delimiter") || isLongOptionAbbrevOf(name, "output-delimiter"));
+    if (tok.startsWith("--")) {
+        if (tok.includes("="))
+            return false;
+        const long = longOptionNameOf(tok);
+        return long !== undefined && model.long.some((full) => isLongOptionAbbrevOf(long, full));
+    }
+    if (!/^-[A-Za-z0-9]/.test(tok))
+        return false;
+    for (let i = 1; i < tok.length; i++) {
+        const ch = tok[i];
+        if ((model.ownsValueButNotSkippable ?? "").includes(ch))
+            return false;
+        if (model.short.includes(ch))
+            return i === tok.length - 1;
+        if (!/[A-Za-z0-9]/.test(ch))
+            return false;
+    }
+    return false;
 }
 function isGrepFileStdinLongOption(tok) {
     const eq = tok.indexOf("=");
@@ -478,19 +518,28 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
             let sawNonFlagOperand = false;
             let hasStdinDash = false;
             let operandCount = 0;
+            let endOfOptions = false;
             if (name !== "tr") {
                 for (let k = 0; k < restArgs.length; k++) {
                     const t = restArgs[k];
-                    if (name === "cut" && (t === "-d" || isCutSeparatedDelimiterOption(t))) {
+                    if (endOfOptions) {
+                    }
+                    else if (t === "--") {
+                        endOfOptions = true;
+                        continue;
+                    }
+                    else if (takesSeparatedValue(name, t)) {
                         k++;
                         continue;
                     }
-                    if (name === "grep" && (isGrepClusterFileStdin(t) || isGrepFileStdinLongOption(t))) {
-                        hasStdinDash = true;
-                        break;
+                    else {
+                        if (name === "grep" && (isGrepClusterFileStdin(t) || isGrepFileStdinLongOption(t))) {
+                            hasStdinDash = true;
+                            break;
+                        }
+                        if (t.startsWith("-") && t !== "-")
+                            continue;
                     }
-                    if (t.startsWith("-") && t !== "-")
-                        continue;
                     const isGrepPatternPosition = name === "grep" && !grepPatternSuppliedByFlag && !sawNonFlagOperand;
                     sawNonFlagOperand = true;
                     operandCount++;

package/dist/tools/fs/fs-bash.js

@@ -14,9 +14,12 @@ import { BASH_READONLY_DEFAULT_ALLOW, coarseReadonlyCheck, classifyBoundedReadon
 export function bashReversibilityProbe(allow, boundary) {
     const allowSet = new Set(allow ?? BASH_READONLY_DEFAULT_ALLOW);
     return (args) => {
-        const command = args?.command;
+        const a = args;
+        const command = a?.command;
         if (typeof command !== "string")
             return { reversible: false };
+        if (a?.run_in_background === true)
+            return { reversible: false };
         const resolved = typeof boundary === "function" ? boundary() : boundary;
         if (classifyCompoundReadonly(command, allowSet, resolved) === undefined)
             return { reversible: true };
@@ -555,8 +558,8 @@ export function createBashTool(env, rootCanonical, coAuthor = false, cwdRef = {
                 const bgCappedByMax = appliedTimeoutSec !== undefined && requestedTimeoutSec !== undefined && typeof bgCaps.maxBgTimeoutSec === "number" && requestedTimeoutSec > bgCaps.maxBgTimeoutSec;
                 const budgetNote = appliedTimeoutSec !== undefined
                     ? bgCappedByMax
-                        ? ` Time budget: requested ${requestedTimeoutSec}s, capped at ${bgCaps.maxBgTimeoutSec}s (env ceiling: requests above ${bgCaps.maxBgTimeoutSec}s are reduced to it) — auto-terminates if still running after ${appliedTimeoutSec}s.`
-                        : ` Time budget: auto-terminates if still running after ${appliedTimeoutSec}s (hard cap ${bgCaps.maxBgTimeoutSec}s).`
+                        ? ` Time budget: requested ${requestedTimeoutSec}s, capped at ${bgCaps.maxBgTimeoutSec}s (env ceiling: requests above ${bgCaps.maxBgTimeoutSec}s are reduced to it) — the process may run up to ${appliedTimeoutSec}s.`
+                        : ` Time budget: the process may run up to ${appliedTimeoutSec}s (hard cap ${bgCaps.maxBgTimeoutSec}s).`
                     : "";
                 const lifetimeNote = backgroundLifetimeNote(bgCaps, bgSessionScoped, bgEnvIsolatedOwned);
                 const registry = taskOpts.taskRegistry;
@@ -655,7 +658,7 @@ export function createBashTool(env, rootCanonical, coAuthor = false, cwdRef = {
                         const tail = stdoutSoFar.slice(-1_000);
                         const adoptCaps = detachEnv.backgroundCapabilities;
                         const adoptBudgetNote = typeof adoptCaps.defaultBgTimeoutSec === "number" && typeof adoptCaps.maxBgTimeoutSec === "number"
-                            ? ` Time budget: auto-terminates if still running after ${Math.min(adoptCaps.defaultBgTimeoutSec, adoptCaps.maxBgTimeoutSec)}s (hard cap ${adoptCaps.maxBgTimeoutSec}s).`
+                            ? ` Time budget: the process may run up to ${Math.min(adoptCaps.defaultBgTimeoutSec, adoptCaps.maxBgTimeoutSec)}s (hard cap ${adoptCaps.maxBgTimeoutSec}s).`
                             : "";
                         return {
                             content: (cause === "timeout"

package/dist/tools/monitor.js

@@ -121,7 +121,7 @@ export function createMonitorTool(env, opts) {
             const envWallMs = bgTimeout !== undefined ? bgTimeout * 1000 : undefined;
             const envWallWins = !isPersistent && envWallMs !== undefined && envWallMs < timeoutMs;
             const persistentBudget = bgTimeout !== undefined
-                ? `the execution environment kills background processes after ${bgTimeout}s`
+                ? `the execution environment's background time budget ends the watch after ${bgTimeout}s`
                 : `the execution environment's background time budget still applies`;
             const retainedByEnv = env.backgroundCapabilities.retainBackgroundProcesses === true;
             const retainedBySpec = opts.retainBackgroundProcesses === true;
@@ -142,8 +142,8 @@ export function createMonitorTool(env, opts) {
             const lifetime = isPersistent
                 ? `It is persistent: no watch timeout of its own${timeoutIgnoredNote}, but ${persistentBudget}${persistentAnchor}`
                 : envWallWins
-                    ? `It will be killed after ${envWallMs}ms if still running — the execution environment's background time budget (${bgTimeout}s) is shorter than the ${timeoutMs}ms watch timeout${clampNote}, and the shorter of the two wins.`
-                    : `It will be killed after ${timeoutMs}ms${clampNote} if still running.`;
+                    ? `The watch may run up to ${envWallMs}ms — the execution environment's background time budget (${bgTimeout}s) is shorter than the ${timeoutMs}ms watch timeout${clampNote}, and the shorter of the two wins.`
+                    : `The watch may run up to ${timeoutMs}ms${clampNote}.`;
             const content = onNotify !== undefined
                 ? `Monitoring in background; task_id=${taskId}. Each stdout line becomes a notification event (lines within ` +
                     `~200ms are batched); you'll get a final notification with the exit code when it ends — do not poll. ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.22.0",
+  "version": "5.24.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -63,7 +63,8 @@
     "gate:domain-lexicon": "node scripts/verify-domain-lexicon.mjs",
     "gate:single-mint": "node scripts/verify-single-mint.mjs",
     "gate:nuia": "node scripts/verify-nuia-baseline.mjs",
-    "gate:field-liveness": "node scripts/verify-field-liveness.mjs"
+    "gate:field-liveness": "node scripts/verify-field-liveness.mjs",
+    "gate:error-surface": "node scripts/verify-error-surface.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",