@sema-agent/core 2.13.0 → 4.0.0

package/dist/stores/file/index.js

@@ -32,6 +32,7 @@ export class FileStorageBackend {
     fileCheckpoints;
     fileMemory;
     ttl;
+    fileSessions;
     fileWorkflowJournal;
     constructor(opts = {}) {
         this.root = resolveDataRoot(opts.root);
@@ -39,6 +40,7 @@ export class FileStorageBackend {
         this.lock.acquire();
         try {
             const repo = new FileSessionRepo(this.root);
+            this.fileSessions = repo;
             this.ttl = new TtlSessionStore({ repo, evict: opts.evict ?? "forget" });
             this.sessionStore = this.ttl;
             this.fileCheckpoints = new FileCheckpointStore(this.root, opts.checkpoint);
@@ -63,6 +65,11 @@ export class FileStorageBackend {
         }
         catch {
         }
+        try {
+            await this.fileSessions.dispose();
+        }
+        catch {
+        }
         this.fileCheckpoints.close();
         try {
             await this.fileMemory.flushEmbeds();

package/dist/stores/file/mailbox-store.d.ts

@@ -1,4 +1,4 @@
-import { type MailboxLease, type MailboxStore } from "../../core/mailbox-store.js";
+import { type MailboxAppendMessage, type MailboxLease, type MailboxStore } from "../../core/mailbox-store.js";
 export interface FileMailboxStoreOptions {
     fsync?: boolean;
     compactEvery?: number;
@@ -15,11 +15,7 @@ export declare class FileMailboxStore implements MailboxStore {
     private load;
     private commit;
     private compact;
-    append(scope: string, handle: string, msg: {
-        from?: string;
-        content: string;
-        sentAt: number;
-    }): Promise<number>;
+    append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;
     claimLease(scope: string, handle: string, owner: string, ttlMs: number, now?: number): Promise<MailboxLease | null>;
     ack(scope: string, handle: string, owner: string, upToSeq: number): Promise<void>;
     releaseLease(scope: string, handle: string, owner: string): Promise<void>;

package/dist/stores/file/session-policy-store.js

@@ -105,11 +105,25 @@ export class FileSessionPolicyStore {
         for (const file of files) {
             if (!file.endsWith(".json"))
                 continue;
+            let raw;
+            try {
+                raw = readFileSync(join(this.dir, file), "utf8");
+            }
+            catch {
+                continue;
+            }
             let parsed;
             try {
-                parsed = JSON.parse(readFileSync(join(this.dir, file), "utf8"));
+                parsed = JSON.parse(raw);
             }
             catch {
+                try {
+                    unlinkSync(join(this.dir, file));
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        throw err;
+                }
                 continue;
             }
             if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))

package/dist/stores/file/session-store.d.ts

@@ -1,22 +1,20 @@
-import type { Session, SessionMetadata, SessionRepo, SessionTreeEntry } from "../../internal/harness.js";
+import type { Session, SessionForkOptions, SessionMetadata, SessionRepo, SessionTreeEntry } from "../../internal/harness.js";
 export declare class FileSessionRepo implements SessionRepo {
     private readonly dir;
     private readonly tmpDir;
+    private readonly joined;
     constructor(root: string);
     private pathFor;
     private read;
     private storage;
+    dispose(): Promise<void>;
     create(options?: {
         id?: string;
     }): Promise<Session>;
     open(metadata: SessionMetadata): Promise<Session>;
     list(): Promise<SessionMetadata[]>;
     delete(metadata: SessionMetadata): Promise<void>;
-    fork(sourceMetadata: SessionMetadata, options?: {
-        entryId?: string;
-        position?: "before" | "at";
-        id?: string;
-    }): Promise<Session>;
+    fork(sourceMetadata: SessionMetadata, options?: SessionForkOptions): Promise<Session>;
     exportEntries(sessionId: string): Promise<SessionTreeEntry[]>;
     importEntries(sessionId: string, owner: string | undefined, entries: SessionTreeEntry[]): Promise<void>;
 }

package/dist/stores/file/session-store.js

@@ -20,11 +20,19 @@ function evictSharedSessionStorage(canonical) {
 class FileSessionStorage extends BaseSessionStorage {
     log;
     canonicalPath;
+    holders = new Set();
     constructor(log, meta, entries, canonicalPath) {
         super(meta, entries);
         this.log = log;
         this.canonicalPath = canonicalPath;
     }
+    addHolder(holder) {
+        this.holders.add(holder);
+    }
+    removeHolder(holder) {
+        this.holders.delete(holder);
+        return this.holders.size === 0;
+    }
     closeLog() {
         this.log.close();
     }
@@ -46,6 +54,7 @@ class FileSessionStorage extends BaseSessionStorage {
 export class FileSessionRepo {
     dir;
     tmpDir;
+    joined = new Map();
     constructor(root) {
         this.dir = join(root, "sessions");
         this.tmpDir = join(root, "tmp");
@@ -77,19 +86,37 @@ export class FileSessionRepo {
     storage(id, createdAt, entries, forkedFrom) {
         const canonical = canonicalStoreKey(this.pathFor(id));
         const live = sharedSessionStorages.get(canonical)?.deref();
-        if (live !== undefined)
+        if (live !== undefined) {
+            live.addHolder(this);
+            this.joined.set(canonical, new WeakRef(live));
             return live;
+        }
         const log = new AppendLog(this.pathFor(id));
         const created = new FileSessionStorage(log, { id, createdAt, ...(forkedFrom !== undefined ? { forkedFrom } : {}) }, entries, canonical);
         sharedSessionStorages.set(canonical, new WeakRef(created));
+        created.addHolder(this);
+        this.joined.set(canonical, new WeakRef(created));
         sessionStorageFinalizer.register(created, { canonical, log }, created);
         return created;
     }
+    async dispose() {
+        for (const [canonical, ref] of this.joined) {
+            const mine = ref.deref();
+            if (mine === undefined)
+                continue;
+            if (sharedSessionStorages.get(canonical)?.deref() !== mine)
+                continue;
+            if (mine.removeHolder(this))
+                evictSharedSessionStorage(canonical);
+        }
+        this.joined.clear();
+    }
     async create(options = {}) {
         const id = options.id ?? uuidv7();
         const createdAt = new Date().toISOString();
         const path = this.pathFor(id);
         if (!existsSync(path)) {
+            evictSharedSessionStorage(canonicalStoreKey(path));
             atomicWriteFile(this.tmpDir, path, `${JSON.stringify({ kind: "meta", id, createdAt })}\n`);
             return new StoredSession(this.storage(id, createdAt, []));
         }

package/dist/stores/file/workflow-journal-store.d.ts

@@ -1,4 +1,4 @@
-import { type WorkflowJournalEntry, type WorkflowJournalStore } from "../../core/workflow-journal-store.js";
+import { type WorkflowJournalEntry, type WorkflowJournalStore, type ResumeClaimArgs } from "../../core/workflow-journal-store.js";
 export { MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult } from "../../core/workflow-journal-store.js";
 export declare const RESUME_CLAIM_TTL_MS: number;
 export declare const RESUME_CLAIM_RELEASE_GRACE_MS = 5000;
@@ -24,19 +24,11 @@ export declare class FileWorkflowJournalStore implements WorkflowJournalStore {
     private readClaimRaw;
     private unlinkIfUnchanged;
     private sweepExpiredClaims;
-    resumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim(input: ResumeClaimArgs): Promise<void>;
     deleteByRun(runId: string): Promise<number>;
     dispose(): void;
 }

package/dist/stores/file/workflow-run-store.d.ts

@@ -1,5 +1,5 @@
-import { type WorkflowRunStore, type WorkflowRunSummary } from "../../core/workflow-run-store.js";
-import type { WorkflowRun, WorkflowRunStatus } from "../../orchestration/workflow.js";
+import { type WorkflowRunListByScopeOptions, type WorkflowRunStore, type WorkflowRunSummary } from "../../core/workflow-run-store.js";
+import type { WorkflowRun } from "../../orchestration/workflow.js";
 export interface FileWorkflowRunStoreOptions {
     fsync?: boolean;
     compactEvery?: number;
@@ -18,11 +18,7 @@ export declare class FileWorkflowRunStore implements WorkflowRunStore {
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRunStatus;
-        limit?: number;
-        session?: string;
-    }): Promise<WorkflowRunSummary[]>;
+    listByScope(scope: string, opts?: WorkflowRunListByScopeOptions): Promise<WorkflowRunSummary[]>;
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
         keep?: number;

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

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { WorkflowRunStoreError, isTerminalWorkflowStatus, summarizeWorkflowRun, } from "../../core/workflow-run-store.js";
+import { WorkflowRunStoreError, isTerminalWorkflowStatus, nextWorkflowRunOnUpdate, queryWorkflowRuns, } from "../../core/workflow-run-store.js";
 import { SharedLedgerTable } from "./shared-ledger.js";
 const runLedgers = new SharedLedgerTable({
     keyOf: (run) => run.id,
@@ -53,28 +53,15 @@ export class FileWorkflowRunStore {
     }
     async update(id, scope, run, expect) {
         return this.withLock(id, () => {
-            const cur = this.runs.get(id);
-            if (!cur || cur.scope !== scope) {
+            const next = nextWorkflowRunOnUpdate(this.runs.get(id), id, scope, run, expect);
+            if (!next)
                 return false;
-            }
-            if (expect !== undefined && (cur.rev ?? 0) !== expect.rev) {
-                return false;
-            }
-            const next = structuredClone(run);
-            next.id = id;
-            next.scope = scope;
-            next.rev = (cur.rev ?? 0) + 1;
             this.commit({ t: "update", id, run: next }, this.fsyncEnabled);
             return true;
         });
     }
     async listByScope(scope, opts) {
-        const rows = [...this.runs.values()].filter((r) => r.scope === scope &&
-            (opts?.status === undefined || r.status === opts.status) &&
-            (opts?.session === undefined || r.originatingSessionId === opts.session));
-        rows.sort((a, b) => b.createdAt - a.createdAt);
-        const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
-        return limited.map(summarizeWorkflowRun);
+        return queryWorkflowRuns(this.runs.values(), scope, opts);
     }
     async reap(scope, now, opts) {
         if (opts?.maxAgeMs === undefined && opts?.keep === undefined)

package/dist/tools/fs/bash-readonly-classifier.d.ts

@@ -14,6 +14,8 @@ export interface CompoundReadonlyVerdict {
     reason?: string;
     outOfRootRead?: true;
     outOfRootPaths?: readonly string[];
+    checkedPaths?: readonly string[];
+    undecidedPaths?: readonly string[];
 }
 export declare function formatOutOfRootReadApprovalOption(directory: string): string;
 export declare function classifyCompoundReadonlyDetailed(command: string, allow: ReadonlySet<string>, boundary?: BashReadonlyRootBoundary): CompoundReadonlyVerdict;

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

@@ -1,4 +1,4 @@
-import { isBlockedDevicePath, normalizeAbsPathLexically, withinAnyRoot } from "./safety.js";
+import { isAbsolutePathForm, isBlockedDevicePath, normalizeAbsPathLexically, withinAnyRoot } from "./safety.js";
 export const BASH_READONLY_DEFAULT_ALLOW = [
     "ls", "cat", "head", "tail", "wc", "pwd", "echo", "whoami", "uname",
     "grep", "cut", "tr", "basename", "dirname", "stat", "du", "df", "which",
@@ -56,31 +56,24 @@ export function formatOutOfRootReadApprovalOption(directory) {
     return `Yes, allow reading from ${leaf || directory}/ from this project`;
 }
 const NO_PATH_OPERAND_COMMANDS = new Set(["pwd", "echo", "whoami", "uname", "which", "tr", "basename", "dirname"]);
-function isAbsolutePathToken(p) {
-    return p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
-}
 function isPathShapedToken(tok) {
     return tok.includes("/") || tok.startsWith("~") || tok === "." || tok === "..";
 }
-function normalizeAbsPathLexicalEitherFamily(p) {
-    const s = p.replace(/\\/g, "/");
-    return /^[A-Za-z]:\//.test(s) ? s.slice(0, 2) + normalizeAbsPathLexically(s.slice(2)) : normalizeAbsPathLexically(s);
-}
 function resolveOperandLexically(base, operand, homeDir) {
     let raw = operand;
     if (raw === "~" || raw.startsWith("~/")) {
-        if (homeDir === undefined || !isAbsolutePathToken(homeDir))
+        if (homeDir === undefined || !isAbsolutePathForm(homeDir))
             return undefined;
         raw = raw === "~" ? homeDir : `${homeDir.replace(/[/\\]+$/, "")}/${raw.slice(2)}`;
     }
     else if (raw.startsWith("~")) {
         return undefined;
     }
-    if (isAbsolutePathToken(raw))
-        return normalizeAbsPathLexicalEitherFamily(raw);
-    if (base === undefined || !isAbsolutePathToken(base))
+    if (isAbsolutePathForm(raw))
+        return normalizeAbsPathLexically(raw);
+    if (base === undefined || !isAbsolutePathForm(base))
         return undefined;
-    return normalizeAbsPathLexicalEitherFamily(`${base.replace(/[/\\]+$/, "")}/${raw}`);
+    return normalizeAbsPathLexically(`${base.replace(/[/\\]+$/, "")}/${raw}`);
 }
 function tokenizeSegment(segment) {
     const raw = segment
@@ -107,6 +100,22 @@ function hasUnquotedExpansionMetachar(rawToken) {
     }
     return false;
 }
+function hasUnquotedGlobMetachar(rawToken) {
+    let open;
+    for (const ch of rawToken) {
+        if (open === undefined && (ch === '"' || ch === "'")) {
+            open = ch;
+            continue;
+        }
+        if (open === ch) {
+            open = undefined;
+            continue;
+        }
+        if (open === undefined && (ch === "*" || ch === "?" || ch === "["))
+            return true;
+    }
+    return false;
+}
 function longOptionNameOf(tok) {
     if (!tok.startsWith("--") || tok.length === 2)
         return undefined;
@@ -179,6 +188,11 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
     const args = tokens.folded.slice(1);
     const findings = [];
     const candidates = [];
+    const bareWordOperands = [];
+    const argGlobs = (k) => {
+        const raw = tokens.raw[k + 1];
+        return raw !== undefined && hasUnquotedGlobMetachar(raw);
+    };
     for (const rawArg of tokens.raw.slice(1)) {
         if (!hasUnquotedExpansionMetachar(rawArg))
             continue;
@@ -190,14 +204,18 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
         ];
     }
     if (name === "cd") {
-        const target = args.find((t) => !t.startsWith("-") || t === "-");
+        const targetIdx = args.findIndex((t) => !t.startsWith("-") || t === "-");
+        const target = targetIdx === -1 ? undefined : args[targetIdx];
+        if (target !== undefined && argGlobs(targetIdx)) {
+            return [{ kind: "unresolvable", reason: `\`cd\` is given the pattern "${target}", which the shell expands to a directory this check cannot know — not auto-allowed` }];
+        }
         if (target === undefined) {
             return [{ kind: "unresolvable", reason: '`cd` with no argument targets the home directory, which cannot be checked against the allowed directories — not auto-allowed' }];
         }
         if (target === "-") {
             return [{ kind: "unresolvable", reason: '`cd -` targets the previous working directory, which cannot be resolved statically — not auto-allowed' }];
         }
-        candidates.push(target);
+        candidates.push({ text: target, globbed: false });
     }
     else {
         const patternSuppliedByFlag = name === "grep" && args.some(isGrepPatternFlagToken);
@@ -214,8 +232,8 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
                 continue;
             if (t.startsWith("-") && t !== "-") {
                 for (const payload of attachedOptionPayloads(t)) {
-                    if (isAbsolutePathToken(payload) || isPathShapedToken(payload))
-                        candidates.push(payload);
+                    if (isAbsolutePathForm(payload) || isPathShapedToken(payload))
+                        candidates.push({ text: payload, globbed: argGlobs(k) });
                 }
                 continue;
             }
@@ -226,10 +244,18 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
             if (isGrepPatternSlot)
                 continue;
             if (isPathShapedToken(t))
-                candidates.push(t);
+                candidates.push({ text: t, globbed: argGlobs(k) });
+            else
+                bareWordOperands.push({ text: t, globbed: argGlobs(k) });
         }
     }
-    for (const candidate of candidates) {
+    for (let k = 0; k < args.length; k++) {
+        if (!argGlobs(k))
+            continue;
+        const resolved = resolveOperandLexically(boundary.cwd ?? boundary.roots[0], args[k], boundary.homeDir);
+        findings.push({ kind: "undecided", path: resolved ?? args[k] });
+    }
+    for (const { text: candidate, globbed } of candidates) {
         const resolved = resolveOperandLexically(boundary.cwd ?? boundary.roots[0], candidate, boundary.homeDir);
         if (resolved === undefined) {
             findings.push({
@@ -238,9 +264,20 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
             });
             continue;
         }
-        if (!withinAnyRoot(boundary.roots, resolved))
+        if (withinAnyRoot(boundary.roots, resolved)) {
+            if (!globbed)
+                findings.push({ kind: "inside", path: resolved });
+        }
+        else
             findings.push({ kind: "outside", command: name, path: resolved });
     }
+    for (const { text: operand, globbed } of bareWordOperands) {
+        const resolved = resolveOperandLexically(boundary.cwd ?? boundary.roots[0], operand, boundary.homeDir);
+        if (resolved === undefined)
+            continue;
+        if (!globbed && withinAnyRoot(boundary.roots, resolved))
+            findings.push({ kind: "inside", path: resolved });
+    }
     return findings;
 }
 export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
@@ -383,22 +420,37 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
 }
 function evaluateReadBoundary(foldedSegments, boundary) {
     const outside = [];
+    const inside = [];
+    const undecided = [];
     for (const toks of foldedSegments) {
         for (const finding of collectSegmentBoundaryFindings(toks, boundary)) {
             if (finding.kind === "unresolvable")
                 return { reason: finding.reason };
+            if (finding.kind === "inside") {
+                if (!inside.includes(finding.path))
+                    inside.push(finding.path);
+                continue;
+            }
+            if (finding.kind === "undecided") {
+                if (!undecided.includes(finding.path))
+                    undecided.push(finding.path);
+                continue;
+            }
             if (!outside.some((o) => o.path === finding.path))
                 outside.push(finding);
         }
     }
+    const undecidedField = undecided.length > 0 ? { undecidedPaths: undecided } : {};
     if (outside.length === 0)
-        return {};
+        return inside.length > 0 ? { checkedPaths: inside, ...undecidedField } : { ...undecidedField };
     const paths = outside.map((o) => `"${o.path}"`).join(", ");
     const allowed = boundary.roots.length > 0 ? boundary.roots.join(", ") : "(none)";
     return {
         reason: `"${outside[0].command}" reads ${paths}, outside the allowed directories for this session: ${allowed} — not auto-allowed`,
         outOfRootRead: true,
         outOfRootPaths: outside.map((o) => o.path),
+        ...(inside.length > 0 ? { checkedPaths: inside } : {}),
+        ...undecidedField,
     };
 }
 export function classifySimpleCommandReadBoundary(command, boundary) {

package/dist/tools/fs/fs-bash.d.ts

@@ -14,7 +14,7 @@ export interface ExecClampOption {
     }) => () => void;
 }
 export declare function bashExitOneInterpretation(command: string): string | undefined;
-export declare function canAutoBackground(command: string): boolean;
+export declare function canAutoBackground(command: string, depth?: number): boolean;
 export declare function createBashTool(env: ExecutionEnv, rootCanonical: string, coAuthor?: string | false, cwdRef?: CwdRef, taskOpts?: {
     taskRegistry?: TaskRegistry;
     taskOwner?: string;