@sema-agent/core 5.21.0 → 5.22.0

package/dist/stores/file/permission-rule-adopt.js

@@ -0,0 +1,95 @@
+import { existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { writerOf } from "../../core/permission-rule-store.js";
+import { syncPermissionRules } from "../../core/permission-rule-sync.js";
+import { FilePermissionRuleStoreProvider, LOCAL_OWNER_FILE, principalRuleFileName, readRuleAdoptionFile, writeRuleAdoptionFile, } from "./permission-rule-store.js";
+export async function adoptFilePermissionRuleStore(opts) {
+    if (typeof opts.toPrincipal !== "string" || opts.toPrincipal === "") {
+        throw new Error("adoptFilePermissionRuleStore requires the adopting principal — adoption is the act of giving this bucket an identity");
+    }
+    if (opts.from.kind === "principal" && opts.from.principal === opts.toPrincipal) {
+        throw new Error(`the bucket already belongs to "${opts.toPrincipal}" — there is nothing to adopt`);
+    }
+    const sourceFile = join(opts.dir, opts.from.kind === "local-owner" ? LOCAL_OWNER_FILE : principalRuleFileName(opts.from.principal));
+    const targetFile = join(opts.dir, principalRuleFileName(opts.toPrincipal));
+    const existing = readRuleAdoptionFile(opts.dir);
+    if (existing !== undefined) {
+        if ("adopted" in existing) {
+            if (existing.adopted.toPrincipal === opts.toPrincipal && sameOwner(existing.adopted.from, opts.from))
+                return { status: "adopted" };
+            throw new Error(`this directory already carries a completed adoption (${ownerText(existing.adopted.from)} → "${existing.adopted.toPrincipal}") — a second adoption of the same directory is not a shape this helper supports`);
+        }
+        if (existing.marker.toPrincipal !== opts.toPrincipal || !sameOwner(existing.marker.from, opts.from)) {
+            throw new Error(`an adoption toward "${existing.marker.toPrincipal}" is already in flight in this directory — refusing to start a different one (resume the original, or repair the marker by hand)`);
+        }
+    }
+    else if (existsSync(targetFile)) {
+        throw new Error(`the target bucket for "${opts.toPrincipal}" already exists — merging two existing buckets goes through an explicit sync join, not a rename`);
+    }
+    const provider = new FilePermissionRuleStoreProvider(opts.dir, opts.onError);
+    try {
+        const lockProbe = writerOf(provider.forPrincipal(opts.toPrincipal));
+        if (lockProbe === undefined)
+            throw new Error("the target store refused a write face");
+        let phase = existing !== undefined && "marker" in existing ? existing.marker.phase : 2;
+        if (existing === undefined) {
+            writeRuleAdoptionFile(opts.dir, marker(opts.from, opts.toPrincipal, 2));
+            phase = 2;
+        }
+        if (phase < 3) {
+            const sourcePresent = existsSync(sourceFile);
+            const targetPresent = existsSync(targetFile);
+            if (sourcePresent && targetPresent) {
+                throw new Error(`both the source and the target bucket exist — merging two existing buckets goes through an explicit sync join, not a rename; the adoption marker is left in place for inspection`);
+            }
+            if (sourcePresent)
+                renameSync(sourceFile, targetFile);
+            writeRuleAdoptionFile(opts.dir, marker(opts.from, opts.toPrincipal, 3));
+            phase = 3;
+        }
+        if (phase < 4) {
+            writeRuleAdoptionFile(opts.dir, marker(opts.from, opts.toPrincipal, 4));
+            phase = 4;
+        }
+        let syncResult;
+        if (phase < 5) {
+            try {
+                syncResult = await syncPermissionRules({
+                    provider,
+                    principal: opts.toPrincipal,
+                    transport: opts.transport,
+                    ...(opts.now !== undefined ? { now: opts.now } : {}),
+                });
+            }
+            catch (err) {
+                return { status: "stalled", phase: 4, error: `the first sync round failed: ${err instanceof Error ? err.message : String(err)}` };
+            }
+            if (!syncResult.ok) {
+                return {
+                    status: "stalled",
+                    phase: 4,
+                    error: `the first sync round did not land clean (${(syncResult.warnings ?? []).join("; ") || `${syncResult.dropped.length} drop(s)`}) — resume when the endpoint is healthy`,
+                };
+            }
+            writeRuleAdoptionFile(opts.dir, marker(opts.from, opts.toPrincipal, 5));
+            phase = 5;
+        }
+        writeRuleAdoptionFile(opts.dir, {
+            schemaVersion: 1,
+            adopted: { from: opts.from, toPrincipal: opts.toPrincipal, atMs: (opts.now ?? Date.now)() },
+        });
+        return { status: "adopted", ...(syncResult !== undefined ? { syncResult } : {}) };
+    }
+    finally {
+        provider.dispose();
+    }
+}
+function marker(from, toPrincipal, phase) {
+    return { schemaVersion: 1, marker: { from, toPrincipal, phase } };
+}
+function sameOwner(a, b) {
+    return a.kind === "principal" ? b.kind === "principal" && a.principal === b.principal : b.kind === "local-owner";
+}
+function ownerText(o) {
+    return o.kind === "principal" ? `principal "${o.principal}"` : "the local owner";
+}

package/dist/stores/file/permission-rule-store.d.ts

@@ -42,9 +42,63 @@
  * and is not: it detects corruption, and it does not detect an editor, because an editor recomputes it.
  * For this backend the trust is host = user, exactly as for the settings file it mirrors.
  */
-import type { PermissionRuleStore, PermissionRuleStoreProvider, PermissionRuleWriter, StoredAllowRules, WritablePermissionRuleStore } from "../../core/permission-rule-store.js";
+import type { PersistedAllowRule, RuleTombstone } from "../../core/permission-rule-model.js";
+import type { PermissionRuleStore, PermissionRuleStoreProvider, PermissionRuleWriter, QuarantinedRuleAdd, RuleOwner, RuleSyncFrontier, StoredAllowRules, WritablePermissionRuleStore } from "../../core/permission-rule-store.js";
 import { PERMISSION_RULE_WRITER } from "../../core/permission-rule-store.js";
+import type { PersistedOrgRuleState } from "../../core/permission-rule-org.js";
 import type { StoreDurability, StoreFidelity } from "../../core/checkpoint-store.js";
+/**
+ * The on-disk shape. `schemaVersion` is the only field a future reader may rely on before validating.
+ *
+ * v1 → v2 (design/182 §8.3): three OPTIONAL blocks — `sync` (observation vector + round timestamp),
+ * `org` (last-known-good org snapshot + anti-rollback high-water) and `quarantined` (rows moved out of
+ * the live view, bytes preserved). The five v1 fields are byte-identical in meaning. A file only ever
+ * ESCALATES to v2 when a write actually carries v2 content (a sync round, an org install, a
+ * quarantine): a deployment that never syncs keeps writing v1 files forever, and a v1 reader handed a
+ * v2 file refuses the whole file loudly (zero rules + disclosure — fail-closed, more asks, and the
+ * documented cost of rolling the engine back under an already-synced store).
+ */
+interface RuleFile {
+    schemaVersion: 1 | 2;
+    actor: string;
+    counter: number;
+    rev: number;
+    rules: PersistedAllowRule[];
+    tombstones: RuleTombstone[];
+    sync?: {
+        observedVector?: RuleSyncFrontier;
+        lastRoundAtMs?: number;
+    };
+    org?: PersistedOrgRuleState;
+    quarantined?: QuarantinedRuleAdd[];
+    checksum: string;
+}
+/** The local-owner bucket's FIXED file name — never a principal-hash path (identity absence is a
+ *  structural position, not a name; design/182 §4.5). Cannot collide with `forPrincipal` names, which
+ *  are 64 hex characters. */
+declare const LOCAL_OWNER_FILE = "local-owner.json";
+/** The durable adoption marker (design/182 §4.5 — the recoverable six-phase state machine's truth). */
+export type RuleAdoptionFile = {
+    schemaVersion: 1;
+    marker: {
+        from: RuleOwner;
+        toPrincipal: string;
+        phase: 2 | 3 | 4 | 5;
+    };
+} | {
+    schemaVersion: 1;
+    adopted: {
+        from: RuleOwner;
+        toPrincipal: string;
+        atMs: number;
+    };
+};
+/** Read the adoption marker, `undefined` when none. A corrupt marker THROWS: after phase 4 the marker
+ *  IS the owner-resolution truth, and guessing on a corrupt truth would either resurrect the retired
+ *  bucket (write fork) or invent an adoption that never happened. */
+export declare function readRuleAdoptionFile(dir: string): RuleAdoptionFile | undefined;
+/** Atomically publish the adoption marker (same write-temp → fsync → rename discipline as the store). */
+export declare function writeRuleAdoptionFile(dir: string, content: RuleAdoptionFile): void;
 /** One principal's rule file. */
 declare class FilePermissionRuleStore implements WritablePermissionRuleStore {
     private readonly dir;
@@ -59,6 +113,14 @@ declare class FilePermissionRuleStore implements WritablePermissionRuleStore {
     private disclose;
     private write;
     list(): Promise<StoredAllowRules>;
+    /** The quarantine area (design/182 §5.2/§8.3): introspection only — never part of `list()`. */
+    quarantined(): Promise<QuarantinedRuleAdd[]>;
+    /** design/182 §7.4 — the durable org block: last-known-good snapshot + anti-rollback high-water,
+     *  installed in ONE atomic publish, surviving restarts. Reading takes no lock (the gate reads);
+     *  installing takes the writer lock (it is a write) but does not move `rev` — nothing about the
+     *  PERSONAL rule set changed, and an OCC holder must not be disturbed (the `nextDot` precedent). */
+    readOrgState(): Promise<PersistedOrgRuleState | undefined>;
+    installOrgState(state: PersistedOrgRuleState): Promise<void>;
     /**
      * The current file, for a WRITE.
      *
@@ -104,8 +166,24 @@ export declare class FilePermissionRuleStoreProvider implements PermissionRuleSt
     /** Take the writer lock, once, on first use of a write face. Reading never calls this. */
     private acquireWriteLock;
     forPrincipal(principal: string | undefined): PermissionRuleStore;
+    /** The read-only resolution of an adoption SOURCE: post-flip (phase ≥ 4 / terminal) always the
+     *  target; pre-flip, whichever path currently holds the bytes (source first — it is the pre-flip
+     *  truth when both somehow exist, which the resume path refuses loudly anyway). */
+    private readOnlySourceView;
+    /**
+     * design/182 §4.5 (F-011) — the identity-less LOCAL bucket: a fixed file name, never a principal-hash
+     * path. Once an adoption reached phase 4 (or its permanent terminal record), local-owner resolution
+     * points at the adopted principal's bucket FOREVER — the marker is the truth the host configuration
+     * reads, not the other way round, so a crash between marker and host-config change cannot fork writes
+     * into a retired bucket. A corrupt marker throws (fail-closed) rather than guessing an owner.
+     */
+    forLocalOwner(): PermissionRuleStore;
     /** Release the writer lock. A long-lived deployment holds it for its lifetime; a test or a short-lived
      *  tool releases so the next holder is not told a live process owns the directory. */
     dispose(): void;
 }
-export type { FilePermissionRuleStore };
+/** The hash-derived file name of one principal's bucket — shared with the adoption helper so the rename
+ *  and the resolver can never disagree about where a principal lives. */
+export declare function principalRuleFileName(principal: string): string;
+export { LOCAL_OWNER_FILE };
+export type { FilePermissionRuleStore, RuleFile };

package/dist/stores/file/permission-rule-store.js

@@ -1,9 +1,78 @@
-import { closeSync, constants as FS, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, constants as FS, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
-import { PERMISSION_RULE_WRITER, applyTombstones, assertDeleteDeltaCarriesNoAdd, foldDelta } from "../../core/permission-rule-store.js";
+import { PERMISSION_RULE_WRITER, applySyncJoin, applyTombstones, assertDeleteDeltaCarriesNoAdd, assertRedemptionNotQuarantined, foldDelta, } from "../../core/permission-rule-store.js";
 import { canonicalize } from "../../core/canonical-json.js";
 import { BootLock } from "./fs-atomic.js";
+const LOCAL_OWNER_FILE = "local-owner.json";
+const ADOPTION_FILE = "PERMISSION-RULES-ADOPTION.json";
+export function readRuleAdoptionFile(dir) {
+    let raw;
+    try {
+        raw = readFileSync(join(dir, ADOPTION_FILE), "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return undefined;
+        throw new Error(`could not read the permission-rule adoption marker in ${dir}: ${err.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`the permission-rule adoption marker in ${dir} is not valid JSON (${err.message}) — refusing to resolve owners until it is repaired`);
+    }
+    if (!isRuleAdoptionFileShape(parsed)) {
+        throw new Error(`the permission-rule adoption marker in ${dir} does not carry a readable shape — refusing to resolve owners until it is repaired`);
+    }
+    return parsed;
+}
+function isRuleAdoptionFileShape(v) {
+    return typeof v === "object" && v !== null && v.schemaVersion === 1 && ("marker" in v || "adopted" in v);
+}
+export function writeRuleAdoptionFile(dir, content) {
+    assertSafeDir(dir);
+    atomicPublish(dir, join(dir, ADOPTION_FILE), JSON.stringify(content, null, 2));
+}
+function atomicPublish(dir, file, payload) {
+    const tmp = join(dir, `.${randomBytes(8).toString("hex")}.tmp`);
+    let fd;
+    try {
+        fd = openSync(tmp, FS.O_WRONLY | FS.O_CREAT | FS.O_EXCL | (FS.O_NOFOLLOW ?? 0), 0o600);
+        writeFileSync(fd, payload);
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(tmp, file);
+        let dfd;
+        try {
+            dfd = openSync(dir, "r");
+            fsyncSync(dfd);
+        }
+        catch {
+        }
+        finally {
+            if (dfd !== undefined)
+                closeSync(dfd);
+        }
+    }
+    catch (err) {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+            }
+        }
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+        }
+        throw err;
+    }
+}
 const EMPTY_READ = { rules: [], tombstones: [], rev: 0 };
 function checksumOf(body) {
     return `sha256:${createHash("sha256").update(canonicalize(body), "utf8").digest("hex")}`;
@@ -64,7 +133,11 @@ class FilePermissionRuleStore {
             this.disclose(why);
             return { unreadable: why };
         }
-        if (parsed?.schemaVersion !== 1 || !Array.isArray(parsed.rules) || !Array.isArray(parsed.tombstones) || typeof parsed.rev !== "number") {
+        if ((parsed?.schemaVersion !== 1 && parsed?.schemaVersion !== 2) ||
+            !Array.isArray(parsed.rules) ||
+            !Array.isArray(parsed.tombstones) ||
+            typeof parsed.rev !== "number" ||
+            (parsed.quarantined !== undefined && !Array.isArray(parsed.quarantined))) {
             const why = `${this.file} does not carry a readable rule-file shape; refusing the whole file and loading zero rules`;
             this.disclose(why);
             return { unreadable: why };
@@ -86,43 +159,7 @@ class FilePermissionRuleStore {
     }
     write(next) {
         assertSafeDir(this.dir);
-        const payload = JSON.stringify({ ...next, checksum: checksumOf(next) }, null, 2);
-        const tmp = join(this.dir, `.${randomBytes(8).toString("hex")}.tmp`);
-        let fd;
-        try {
-            fd = openSync(tmp, FS.O_WRONLY | FS.O_CREAT | FS.O_EXCL | (FS.O_NOFOLLOW ?? 0), 0o600);
-            writeFileSync(fd, payload);
-            fsyncSync(fd);
-            closeSync(fd);
-            fd = undefined;
-            renameSync(tmp, this.file);
-            let dfd;
-            try {
-                dfd = openSync(this.dir, "r");
-                fsyncSync(dfd);
-            }
-            catch {
-            }
-            finally {
-                if (dfd !== undefined)
-                    closeSync(dfd);
-            }
-        }
-        catch (err) {
-            if (fd !== undefined) {
-                try {
-                    closeSync(fd);
-                }
-                catch {
-                }
-            }
-            try {
-                unlinkSync(tmp);
-            }
-            catch {
-            }
-            throw err;
-        }
+        atomicPublish(this.dir, this.file, JSON.stringify({ ...next, checksum: checksumOf(next) }, null, 2));
     }
     async list() {
         const r = this.read();
@@ -135,14 +172,50 @@ class FilePermissionRuleStore {
             checksum: r.file.checksum,
         };
     }
+    async quarantined() {
+        const r = this.read();
+        return "file" in r ? (r.file.quarantined ?? []) : [];
+    }
+    async readOrgState() {
+        const r = this.read();
+        return "file" in r ? r.file.org : undefined;
+    }
+    async installOrgState(state) {
+        this.acquireWriteLock();
+        await this.serialize(() => {
+            const cur = this.current();
+            if (cur.org !== undefined && state.revisionHighWater < cur.org.revisionHighWater) {
+                throw new Error(`refusing to lower the org revision high-water mark (${cur.org.revisionHighWater} → ${state.revisionHighWater}) — an interleaved install must re-read and re-compare`);
+            }
+            if (cur.org !== undefined &&
+                state.snapshot.revision === cur.org.snapshot.revision &&
+                canonicalize(state.snapshot.rules) !== canonicalize(cur.org.snapshot.rules)) {
+                throw new Error(`refusing to replace org revision ${state.snapshot.revision} with DIFFERENT policy content under the same revision — content changes must bump the revision`);
+            }
+            if (!this.writeAndVerify({ ...cur, schemaVersion: 2, org: state })) {
+                throw new Error("the permission-rule store did not survive its own write; the org snapshot was not installed");
+            }
+        });
+    }
     current() {
         const r = this.read();
         if ("unreadable" in r) {
             throw new Error(`refusing to write the permission-rule store while it cannot be read: ${r.unreadable}`);
         }
-        return "absent" in r
-            ? { schemaVersion: 1, actor: `file-${randomBytes(6).toString("hex")}`, counter: 0, rev: 0, rules: [], tombstones: [] }
-            : { schemaVersion: 1, actor: r.file.actor, counter: r.file.counter, rev: r.file.rev, rules: r.file.rules, tombstones: r.file.tombstones };
+        if ("absent" in r) {
+            return { schemaVersion: 1, actor: `file-${randomBytes(6).toString("hex")}`, counter: 0, rev: 0, rules: [], tombstones: [] };
+        }
+        return {
+            schemaVersion: r.file.schemaVersion,
+            actor: r.file.actor,
+            counter: r.file.counter,
+            rev: r.file.rev,
+            rules: r.file.rules,
+            tombstones: r.file.tombstones,
+            ...(r.file.sync !== undefined ? { sync: r.file.sync } : {}),
+            ...(r.file.org !== undefined ? { org: r.file.org } : {}),
+            ...(r.file.quarantined !== undefined ? { quarantined: r.file.quarantined } : {}),
+        };
     }
     writeAndVerify(next) {
         const expected = checksumOf(next);
@@ -169,12 +242,50 @@ class FilePermissionRuleStore {
             }
             return dot;
         }),
+        readRaw: async () => this.serialize(() => {
+            const cur = this.current();
+            return {
+                actor: cur.actor,
+                counter: cur.counter,
+                rev: cur.rev,
+                rules: structuredClone(cur.rules),
+                tombstones: structuredClone(cur.tombstones),
+                ...(cur.sync?.observedVector !== undefined ? { observedVector: structuredClone(cur.sync.observedVector) } : {}),
+                quarantined: structuredClone(cur.quarantined ?? []),
+            };
+        }),
         apply: async (delta, opts) => this.serialize(() => {
             const cur = this.current();
             if (cur.rev !== opts.expectedRev)
                 return { conflict: true, rev: cur.rev };
+            if (delta.kind === "sync-join") {
+                const { next, report } = applySyncJoin({
+                    actor: cur.actor,
+                    counter: cur.counter,
+                    rules: cur.rules,
+                    tombstones: cur.tombstones,
+                    quarantined: cur.quarantined ?? [],
+                    ...(cur.sync?.observedVector !== undefined ? { observedVector: cur.sync.observedVector } : {}),
+                }, delta, Date.now());
+                const landed = {
+                    ...cur,
+                    schemaVersion: 2,
+                    rev: cur.rev + 1,
+                    rules: next.rules,
+                    tombstones: next.tombstones,
+                    sync: {
+                        ...(next.observedVector !== undefined ? { observedVector: next.observedVector } : {}),
+                        lastRoundAtMs: Date.now(),
+                    },
+                    ...(next.quarantined.length > 0 ? { quarantined: next.quarantined } : {}),
+                };
+                if (!this.writeAndVerify(landed)) {
+                    throw new Error("the permission-rule store did not survive its own write; the change was not committed");
+                }
+                return { rev: cur.rev + 1, sync: report };
+            }
             const next = delta.kind === "redemption-add"
-                ? { ...cur, rev: cur.rev + 1, rules: foldDelta(cur.rules, delta) }
+                ? (assertRedemptionNotQuarantined(cur.quarantined ?? [], delta), { ...cur, rev: cur.rev + 1, rules: foldDelta(cur.rules, delta) })
                 : (assertDeleteDeltaCarriesNoAdd(delta), { ...cur, rev: cur.rev + 1, tombstones: [...cur.tombstones, delta.tombstone] });
             if (!this.writeAndVerify(next)) {
                 throw new Error("the permission-rule store did not survive its own write; the change was not committed");
@@ -203,11 +314,43 @@ export class FilePermissionRuleStoreProvider {
         if (typeof principal !== "string" || principal === "") {
             return { list: async () => ({ ...EMPTY_READ }), durability: "process-local" };
         }
-        const name = `${createHash("sha256").update(principal, "utf8").digest("hex")}.json`;
-        return new FilePermissionRuleStore(this.dir, join(this.dir, name), this.acquireWriteLock, this.onError);
+        const adoption = readRuleAdoptionFile(this.dir);
+        if (adoption !== undefined) {
+            const rec = "adopted" in adoption ? adoption.adopted : adoption.marker;
+            if (rec.from.kind === "principal" && rec.from.principal === principal) {
+                return this.readOnlySourceView(principalRuleFileName(principal), principalRuleFileName(rec.toPrincipal), "adopted" in adoption || adoption.marker.phase >= 4);
+            }
+        }
+        return new FilePermissionRuleStore(this.dir, join(this.dir, principalRuleFileName(principal)), this.acquireWriteLock, this.onError);
+    }
+    readOnlySourceView(sourceName, targetName, flipped) {
+        const pick = flipped ? targetName : existsSync(join(this.dir, sourceName)) ? sourceName : targetName;
+        return readOnlyRuleStoreView(new FilePermissionRuleStore(this.dir, join(this.dir, pick), this.acquireWriteLock, this.onError));
+    }
+    forLocalOwner() {
+        const adoption = readRuleAdoptionFile(this.dir);
+        if (adoption !== undefined) {
+            const rec = "adopted" in adoption ? adoption.adopted : adoption.marker;
+            if (rec.from.kind === "local-owner") {
+                return this.readOnlySourceView(LOCAL_OWNER_FILE, principalRuleFileName(rec.toPrincipal), "adopted" in adoption || adoption.marker.phase >= 4);
+            }
+        }
+        return new FilePermissionRuleStore(this.dir, join(this.dir, LOCAL_OWNER_FILE), this.acquireWriteLock, this.onError);
     }
     dispose() {
         this.lock?.release();
         this.lock = undefined;
     }
 }
+function readOnlyRuleStoreView(store) {
+    return {
+        list: () => store.list(),
+        ...(store.quarantined !== undefined ? { quarantined: () => store.quarantined() } : {}),
+        ...(store.durability !== undefined ? { durability: store.durability } : {}),
+        ...(store.fidelity !== undefined ? { fidelity: store.fidelity } : {}),
+    };
+}
+export function principalRuleFileName(principal) {
+    return `${createHash("sha256").update(principal, "utf8").digest("hex")}.json`;
+}
+export { LOCAL_OWNER_FILE };

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

@@ -206,7 +206,6 @@ export function createGlobTool(env, rootCanonical, additionalRoots) {
 export const HAND_TOOL_EFFECTS = {
     Read: "read",
     Edit: "write",
-    MultiEdit: "write",
     Write: "write",
     NotebookEdit: "write",
     Grep: "read",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.21.0",
+  "version": "5.22.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",