@sema-agent/core 3.0.0 → 4.0.0

package/dist/prompt-assembly/tool-catalog.d.ts

@@ -11,6 +11,15 @@ export interface ToolContractDescriptor {
     wireSchemaDigest: string;
     cardId: string;
 }
+export interface ToolManifestRow {
+    wireName: string;
+    aliases: string[];
+    contractId: string;
+    implementationRevision: string;
+    cardId: string;
+    shapeDigest: string;
+    wireSchemaDigest: string;
+}
 export declare function computeShapeDigest(schema: TSchema | undefined): string;
 export declare function computeWireSchemaDigest(schema: TSchema | undefined, description: string): string;
 export interface AttachContractInput {
@@ -22,15 +31,7 @@ export interface AttachContractInput {
 export declare function attachToolContract(tool: AgentTool, input: AttachContractInput): void;
 export declare function getToolContract(tool: AgentTool, fallbackOrigin?: ToolOrigin): ToolContractDescriptor;
 export declare function hasToolContract(tool: AgentTool): boolean;
-export declare function projectToolManifest(tools: AgentTool[], originOf?: (tool: AgentTool) => ToolOrigin): Array<{
-    wireName: string;
-    aliases: string[];
-    contractId: string;
-    implementationRevision: string;
-    cardId: string;
-    shapeDigest: string;
-    wireSchemaDigest: string;
-}>;
+export declare function projectToolManifest(tools: AgentTool[], originOf?: (tool: AgentTool) => ToolOrigin): ToolManifestRow[];
 export declare function auditToolCollisions(tools: AgentTool[]): {
     yields: Array<{
         name: string;

package/dist/prompt-assembly/turn-snapshot.d.ts

@@ -1,3 +1,4 @@
+import type { ToolFingerprintInput } from "../core/cache-break-detector.js";
 export interface RawPrefixInputs {
     provider: string;
     modelId: string;
@@ -9,11 +10,7 @@ export interface RawPrefixInputs {
         cacheControlBoundary: boolean;
     }>;
     stableSystemText: string;
-    toolWire: ReadonlyArray<{
-        name: string;
-        description: string;
-        parameters: unknown;
-    }>;
+    toolWire: ReadonlyArray<ToolFingerprintInput>;
     thinkingLevel: string;
     maxTokens: number | undefined;
     hasOutputSchema: boolean;

package/dist/stores/file/background-agent-store.d.ts

@@ -1,4 +1,4 @@
-import { type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentStore } from "../../core/background-agent-store.js";
+import { type BackgroundAgentReapOptions, type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentStore, type BackgroundAgentUpdateIfExpect } from "../../core/background-agent-store.js";
 export interface FileBackgroundAgentStoreOptions {
     fsync?: boolean;
     compactEvery?: number;
@@ -18,12 +18,7 @@ export declare class FileBackgroundAgentStore implements BackgroundAgentStore {
     update(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
         rev: number;
     }): Promise<boolean>;
-    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: {
-        rev: number;
-        status?: BackgroundAgentRecord["status"];
-        parkedCheckpointToken?: string | null;
-        parkClaimId?: string | null;
-    }): Promise<boolean>;
+    updateIf(handle: string, scope: string, record: BackgroundAgentRecord, expect: BackgroundAgentUpdateIfExpect): Promise<boolean>;
     listBySession(scope: string, sessionId: string, opts?: {
         status?: BackgroundAgentRecord["status"];
         limit?: number;
@@ -36,11 +31,7 @@ export declare class FileBackgroundAgentStore implements BackgroundAgentStore {
     delete(handle: string, scope: string, expect?: {
         rev: number;
     }): Promise<boolean>;
-    reap(scope: string, now: number, opts?: {
-        maxAgeMs?: number;
-        keep?: number;
-        staleRunningMaxAgeMs?: number;
-    }): Promise<number>;
+    reap(scope: string, now: number, opts?: BackgroundAgentReapOptions): Promise<number>;
     compactNow(): void;
     get size(): number;
     close(): void;

package/dist/stores/file/background-agent-store.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, } from "../../core/background-agent-store.js";
+import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, queryBackgroundAgents, } from "../../core/background-agent-store.js";
 import { SharedLedgerTable } from "./shared-ledger.js";
 const agentLedgers = new SharedLedgerTable({
     keyOf: (r) => FileBackgroundAgentStore.key(r.handle, r.scope),
@@ -92,31 +92,10 @@ export class FileBackgroundAgentStore {
         });
     }
     async listBySession(scope, sessionId, opts) {
-        const out = [];
-        for (const r of this.rows.values()) {
-            if (r.scope !== scope)
-                continue;
-            const anchor = r.sessionScoped ? r.owner : r.parentSessionId;
-            if (anchor !== sessionId && r.rootSessionId !== sessionId)
-                continue;
-            if (opts?.status !== undefined && r.status !== opts.status)
-                continue;
-            out.push(toSummary(r));
-        }
-        out.sort((a, b) => b.spawnedAt - a.spawnedAt);
-        return opts?.limit !== undefined ? out.slice(0, Math.max(0, opts.limit)) : out;
+        return queryBackgroundAgents(this.rows.values(), { scope, sessionId, status: opts?.status, limit: opts?.limit });
     }
     async listByScope(scope, opts) {
-        const out = [];
-        for (const r of this.rows.values()) {
-            if (r.scope !== scope)
-                continue;
-            if (opts?.status !== undefined && r.status !== opts.status)
-                continue;
-            out.push(toSummary(r));
-        }
-        out.sort((a, b) => b.spawnedAt - a.spawnedAt);
-        return opts?.limit !== undefined ? out.slice(0, Math.max(0, opts.limit)) : out;
+        return queryBackgroundAgents(this.rows.values(), { scope, status: opts?.status, limit: opts?.limit });
     }
     async listScopes() {
         return [...new Set([...this.rows.values()].map((r) => r.scope))].sort();
@@ -205,20 +184,3 @@ export class FileBackgroundAgentStore {
         this.ledger.release();
     }
 }
-function toSummary(r) {
-    return {
-        handle: r.handle,
-        owner: r.owner,
-        sessionScoped: r.sessionScoped,
-        ...(r.sessionId !== undefined ? { sessionId: r.sessionId } : {}),
-        ...(r.parentSessionId !== undefined ? { parentSessionId: r.parentSessionId } : {}),
-        ...(r.rootSessionId !== undefined ? { rootSessionId: r.rootSessionId } : {}),
-        ...(r.name !== undefined ? { name: r.name } : {}),
-        ...(r.agentType !== undefined ? { agentType: r.agentType } : {}),
-        status: r.status,
-        spawnedAt: r.spawnedAt,
-        updatedAt: r.updatedAt,
-        ...(r.settledAt !== undefined ? { settledAt: r.settledAt } : {}),
-        ...(r.usage !== undefined ? { usage: structuredClone(r.usage) } : {}),
-    };
-}

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

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { CheckpointError, summarizeCheckpoint, validatePendingSteer, winnerFromOutcome, } from "../../core/checkpoint-store.js";
+import { CheckpointError, checkpointOccMatches, checkpointRowMatches, summarizeCheckpoint, validatePendingSteer, winnerFromOutcome, } from "../../core/checkpoint-store.js";
 import { SharedLedgerTable } from "./shared-ledger.js";
 function applyCheckpointEvent(cps, ev) {
     if (ev.t === "put") {
@@ -80,10 +80,10 @@ export class FileCheckpointStore {
                 throw new Error("injected fault: resolve before commit");
             }
             const cp = this.cps.get(token);
-            if (!cp || cp.scope !== scope || cp.status !== "pending") {
+            if (!checkpointRowMatches(cp, scope, "pending")) {
                 return false;
             }
-            if (expect !== undefined && (cp.rev ?? 0) !== expect.rev) {
+            if (!checkpointOccMatches(cp, expect)) {
                 return false;
             }
             const winner = winnerFromOutcome(outcome);
@@ -99,7 +99,7 @@ export class FileCheckpointStore {
     async reopen(token, scope, reason) {
         return this.withLock(token, () => {
             const cp = this.cps.get(token);
-            if (!cp || cp.scope !== scope || cp.status !== "resolved") {
+            if (!checkpointRowMatches(cp, scope, "resolved")) {
                 return false;
             }
             const rev = (cp.rev ?? 0) + 1;
@@ -111,7 +111,7 @@ export class FileCheckpointStore {
         const clean = validatePendingSteer(steer);
         return this.withLock(token, () => {
             const cp = this.cps.get(token);
-            if (!cp || cp.scope !== scope || cp.status !== "pending") {
+            if (!checkpointRowMatches(cp, scope, "pending")) {
                 return false;
             }
             this.commit({ t: "steer", token, steer: clean }, this.fsyncEnabled);
@@ -121,7 +121,7 @@ export class FileCheckpointStore {
     async expire(token, scope) {
         return this.withLock(token, () => {
             const cp = this.cps.get(token);
-            if (!cp || cp.scope !== scope || cp.status !== "pending") {
+            if (!checkpointRowMatches(cp, scope, "pending")) {
                 return false;
             }
             this.commit({ t: "expire", token }, true);

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,4 +1,4 @@
-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;
@@ -14,11 +14,7 @@ export declare class FileSessionRepo implements SessionRepo {
     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/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

@@ -15,6 +15,7 @@ export interface CompoundReadonlyVerdict {
     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;
@@ -180,6 +189,10 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
     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;
@@ -191,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);
@@ -215,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;
             }
@@ -227,12 +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(t);
+                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({
@@ -241,14 +264,18 @@ function collectSegmentBoundaryFindings(tokens, boundary) {
             });
             continue;
         }
-        if (withinAnyRoot(boundary.roots, resolved))
-            findings.push({ kind: "inside", path: 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 operand of bareWordOperands) {
+    for (const { text: operand, globbed } of bareWordOperands) {
         const resolved = resolveOperandLexically(boundary.cwd ?? boundary.roots[0], operand, boundary.homeDir);
-        if (resolved !== undefined && withinAnyRoot(boundary.roots, resolved))
+        if (resolved === undefined)
+            continue;
+        if (!globbed && withinAnyRoot(boundary.roots, resolved))
             findings.push({ kind: "inside", path: resolved });
     }
     return findings;
@@ -394,6 +421,7 @@ 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")
@@ -403,12 +431,18 @@ function evaluateReadBoundary(foldedSegments, boundary) {
                     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 inside.length > 0 ? { checkedPaths: inside } : {};
+        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 {
@@ -416,6 +450,7 @@ function evaluateReadBoundary(foldedSegments, boundary) {
         outOfRootRead: true,
         outOfRootPaths: outside.map((o) => o.path),
         ...(inside.length > 0 ? { checkedPaths: inside } : {}),
+        ...undecidedField,
     };
 }
 export function classifySimpleCommandReadBoundary(command, boundary) {