@cjhyy/code-shell-core 0.9.2 → 0.9.4

package/dist/tool-system/builtin/agent-notifications.js

@@ -1,9 +1,78 @@
 import { nanoid } from "nanoid";
+import { closeSync, constants, existsSync, fstatSync, lstatSync, openSync, readFileSync, renameSync, } from "node:fs";
 import { logger } from "../../logging/logger.js";
+import { mutateJsonFile } from "../../utils/file-mutex.js";
 const EMPTY = Object.freeze([]);
+const PERSISTENCE_SCHEMA_VERSION = 1;
+const MAX_PERSISTED_BYTES = 16 * 1024 * 1024;
 function isValidSessionId(value) {
     return typeof value === "string" && value.length > 0;
 }
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNotificationAuthority(value) {
+    return value === "user" || value === "agent" || value === "system" || value === "policy";
+}
+function isEndpoint(value) {
+    if (!isRecord(value) || !isValidSessionId(value.sessionId))
+        return false;
+    if (value.agentId !== undefined && typeof value.agentId !== "string")
+        return false;
+    return isNotificationAuthority(value.authority);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isResultPayload(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isValidSessionId(value.workId) || typeof value.description !== "string")
+        return false;
+    if (value.status !== "completed" && value.status !== "failed" && value.status !== "cancelled") {
+        return false;
+    }
+    if (value.workKind !== "agent" &&
+        value.workKind !== "shell" &&
+        value.workKind !== "video" &&
+        value.workKind !== "cc") {
+        return false;
+    }
+    if (!Number.isFinite(value.finishedAt))
+        return false;
+    if (!isOptionalString(value.name) ||
+        !isOptionalString(value.finalText) ||
+        !isOptionalString(value.error) ||
+        !isOptionalString(value.command) ||
+        !isOptionalString(value.ccSessionId) ||
+        !isOptionalString(value.cwd) ||
+        !isOptionalString(value.originClientMessageId)) {
+        return false;
+    }
+    return (value.changedFiles === undefined ||
+        (Array.isArray(value.changedFiles) &&
+            value.changedFiles.every((item) => typeof item === "string")));
+}
+function isPersistedResultEnvelope(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.schemaVersion !== 1 ||
+        value.kind !== "result" ||
+        value.delivery !== "idle-drain" ||
+        !isValidSessionId(value.id) ||
+        !isEndpoint(value.from) ||
+        !isEndpoint(value.to) ||
+        !Number.isSafeInteger(value.sequence) ||
+        value.sequence < 1 ||
+        !Number.isFinite(value.createdAt) ||
+        !isResultPayload(value.payload)) {
+        return false;
+    }
+    if (value.teamId !== undefined || !isOptionalString(value.correlationId))
+        return false;
+    return (value.runtimeGeneration === undefined ||
+        (Number.isSafeInteger(value.runtimeGeneration) && value.runtimeGeneration > 0));
+}
 function routeSequenceKey(draft) {
     return [
         draft.teamId ?? "tree",
@@ -83,12 +152,122 @@ function installLegacyResultAliases(envelope) {
         Object.defineProperty(envelope, name, { configurable: false, enumerable: false, get });
     }
 }
-class NotificationQueue {
+export class NotificationQueue {
     buckets = new Map();
     listeners = new Set();
     sequences = new Map();
     sequenceRoutes = new Map();
+    persistence = null;
+    restoredSessions = new Set();
     maxSequenceRoutes = 4_096;
+    attachPersistence(persistence) {
+        this.persistence = persistence;
+        this.restoredSessions.clear();
+    }
+    /** Restore every persisted mailbox discovered by the host during startup. */
+    restorePersistedSessions() {
+        const restored = [];
+        for (const sessionId of this.persistence?.listSessionIds?.() ?? []) {
+            if (!isValidSessionId(sessionId) || this.restoredSessions.has(sessionId))
+                continue;
+            this.restorePersistedSession(sessionId);
+            if (this.resultSnapshot(sessionId).length > 0)
+                restored.push(sessionId);
+        }
+        return restored;
+    }
+    restorePersistedSession(sessionId) {
+        if (!isValidSessionId(sessionId) || this.restoredSessions.has(sessionId))
+            return 0;
+        this.restoredSessions.add(sessionId);
+        const file = this.persistence?.fileForSession(sessionId) ?? null;
+        if (!file || !existsSync(file))
+            return 0;
+        let pathInfo;
+        try {
+            pathInfo = lstatSync(file);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            this.restoredSessions.delete(sessionId);
+            logger.warn("notification_queue.persistence_read_failed", {
+                file,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return 0;
+        }
+        if (pathInfo.isSymbolicLink() || !pathInfo.isFile() || pathInfo.size > MAX_PERSISTED_BYTES) {
+            this.quarantineCorruptFile(file, new Error("pending notification file is not a bounded regular file"));
+            return 0;
+        }
+        let raw;
+        try {
+            const descriptor = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+            try {
+                const opened = fstatSync(descriptor);
+                if (!opened.isFile() || opened.size > MAX_PERSISTED_BYTES) {
+                    throw new Error("pending notification file is not a bounded regular file");
+                }
+                raw = readFileSync(descriptor, "utf8");
+            }
+            finally {
+                closeSync(descriptor);
+            }
+        }
+        catch (error) {
+            this.restoredSessions.delete(sessionId);
+            logger.warn("notification_queue.persistence_read_failed", {
+                file,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return 0;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            this.quarantineCorruptFile(file, error);
+            return 0;
+        }
+        if (!isRecord(parsed) ||
+            parsed.schemaVersion !== PERSISTENCE_SCHEMA_VERSION ||
+            !Array.isArray(parsed.results)) {
+            this.quarantineCorruptFile(file, new Error("invalid pending notification schema"));
+            return 0;
+        }
+        const valid = [];
+        const invalid = [];
+        for (const candidate of parsed.results) {
+            if (isPersistedResultEnvelope(candidate) && candidate.to.sessionId === sessionId) {
+                installLegacyResultAliases(candidate);
+                valid.push(candidate);
+            }
+            else {
+                invalid.push(candidate);
+            }
+        }
+        if (invalid.length > 0) {
+            this.quarantineCorruptFile(file, new Error(`${invalid.length} invalid pending notification entries`));
+            // Merge the salvaged rows back under the directory lock. A concurrent
+            // writer may already have recreated the active path after quarantine;
+            // replacing it with this earlier snapshot would lose that new result.
+            this.persistAddedResults(sessionId, valid);
+        }
+        if (valid.length === 0)
+            return 0;
+        const bucket = this.buckets.get(sessionId) ?? [];
+        const ids = new Set(bucket.map((item) => item.id));
+        const restored = valid.filter((item) => !ids.has(item.id));
+        if (restored.length === 0)
+            return 0;
+        this.buckets.set(sessionId, [...restored, ...bucket]);
+        for (const envelope of restored)
+            this.reseedSequence(envelope);
+        this.notify();
+        return restored.length;
+    }
     enqueue(draftOrItem, legacySessionId) {
         const draft = legacySessionId !== undefined || !("kind" in draftOrItem)
             ? legacyItemToDraft(draftOrItem, legacySessionId)
@@ -112,6 +291,7 @@ class NotificationQueue {
             logger.warn("notification_queue.invalid_direction_draft");
             return undefined;
         }
+        this.restorePersistedSession(draft.to.sessionId);
         const sequenceKey = routeSequenceKey(draft);
         const sequence = (this.sequences.get(sequenceKey) ?? 0) + 1;
         const id = nanoid();
@@ -154,6 +334,9 @@ class NotificationQueue {
             this.sequences.delete(oldest);
         }
         this.buckets.set(envelope.to.sessionId, [...next, envelope]);
+        if (envelope.kind === "result") {
+            this.persistAddedResults(envelope.to.sessionId, [envelope]);
+        }
         this.notify();
         agentNotificationBus.publish(envelope);
         return envelope;
@@ -165,11 +348,13 @@ class NotificationQueue {
     getSnapshot = (sessionId) => {
         if (!isValidSessionId(sessionId))
             return EMPTY;
+        this.restorePersistedSession(sessionId);
         return this.buckets.get(sessionId) ?? EMPTY;
     };
     drain(sessionId, predicate) {
         if (!isValidSessionId(sessionId))
             return [];
+        this.restorePersistedSession(sessionId);
         const bucket = this.buckets.get(sessionId);
         if (!bucket?.length)
             return [];
@@ -184,6 +369,9 @@ class NotificationQueue {
             this.buckets.set(sessionId, retained);
         else
             this.buckets.delete(sessionId);
+        this.persistRemovedResults(sessionId, drained
+            .filter((item) => item.kind === "result")
+            .map((item) => item.id));
         this.notify();
         return drained;
     }
@@ -201,12 +389,16 @@ class NotificationQueue {
     restoreResults(sessionId, envelopes) {
         if (!isValidSessionId(sessionId) || envelopes.length === 0)
             return 0;
+        this.restorePersistedSession(sessionId);
         const bucket = this.buckets.get(sessionId) ?? [];
         const ids = new Set(bucket.map((item) => item.id));
         const restored = envelopes.filter((item) => item.kind === "result" && item.to.sessionId === sessionId && !ids.has(item.id));
         if (restored.length === 0)
             return 0;
         this.buckets.set(sessionId, [...restored, ...bucket]);
+        for (const envelope of restored)
+            this.reseedSequence(envelope);
+        this.persistAddedResults(sessionId, restored);
         this.notify();
         return restored.length;
     }
@@ -242,13 +434,23 @@ class NotificationQueue {
     }
     reset(sessionId) {
         if (sessionId === undefined) {
-            if (this.buckets.size === 0 && this.sequences.size === 0)
+            if (this.buckets.size === 0 && this.sequences.size === 0) {
+                this.restoredSessions.clear();
                 return;
+            }
+            const persistedSessions = [...this.buckets.keys()];
             this.buckets.clear();
             this.sequences.clear();
             this.sequenceRoutes.clear();
+            for (const persistedSession of persistedSessions) {
+                const file = this.persistence?.fileForSession(persistedSession) ?? null;
+                if (file)
+                    this.replacePersistedResults(file, []);
+            }
+            this.restoredSessions.clear();
         }
         else {
+            this.restorePersistedSession(sessionId);
             const hadBucket = this.buckets.delete(sessionId);
             let clearedRoute = false;
             for (const [key, route] of this.sequenceRoutes) {
@@ -260,9 +462,139 @@ class NotificationQueue {
             }
             if (!hadBucket && !clearedRoute)
                 return;
+            const file = this.persistence?.fileForSession(sessionId) ?? null;
+            if (file)
+                this.replacePersistedResults(file, []);
+            this.restoredSessions.delete(sessionId);
         }
         this.notify();
     }
+    resultSnapshot(sessionId) {
+        return (this.buckets.get(sessionId) ?? []).filter((item) => item.kind === "result");
+    }
+    persistAddedResults(sessionId, results) {
+        if (results.length === 0)
+            return;
+        const file = this.persistence?.fileForSession(sessionId) ?? null;
+        if (!file)
+            return;
+        try {
+            this.mutatePersistedResults(file, (current) => {
+                const merged = [...current.results];
+                const ids = new Set(merged.map((item) => item.id));
+                for (const result of results) {
+                    if (ids.has(result.id))
+                        continue;
+                    ids.add(result.id);
+                    merged.push(result);
+                }
+                // Always return the validated state: parse may have quarantined a
+                // mixed-validity file, in which case even a duplicate add must reseed
+                // the active path with the valid rows.
+                return merged;
+            });
+        }
+        catch (error) {
+            logger.error("notification_queue.persistence_write_failed", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    persistRemovedResults(sessionId, resultIds) {
+        if (resultIds.length === 0)
+            return;
+        const file = this.persistence?.fileForSession(sessionId) ?? null;
+        if (!file)
+            return;
+        try {
+            const removed = new Set(resultIds);
+            this.mutatePersistedResults(file, (current) => {
+                const retained = current.results.filter((item) => !removed.has(item.id));
+                return retained;
+            });
+        }
+        catch (error) {
+            logger.error("notification_queue.persistence_write_failed", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    replacePersistedResults(file, results) {
+        this.mutatePersistedResults(file, () => [...results]);
+    }
+    /**
+     * Cross-process mailbox mutation. The directory lock exists before the JSON
+     * file does, and the current contents are re-read inside that lock. This
+     * avoids both the old lock-outside seed race and stale-snapshot overwrite.
+     */
+    mutatePersistedResults(file, mutation) {
+        mutateJsonFile(file, {
+            parse: (raw) => this.parsePersistedResultsForMutation(file, raw),
+            serialize: (value) => `${JSON.stringify(value, null, 2)}\n`,
+            mutation: (current) => {
+                const results = mutation(current);
+                return results === undefined
+                    ? {}
+                    : {
+                        value: {
+                            schemaVersion: PERSISTENCE_SCHEMA_VERSION,
+                            results,
+                        },
+                    };
+            },
+            mode: 0o600,
+            maxBytes: MAX_PERSISTED_BYTES,
+        });
+    }
+    parsePersistedResultsForMutation(file, raw) {
+        if (raw === undefined) {
+            return { schemaVersion: PERSISTENCE_SCHEMA_VERSION, results: [] };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            this.quarantineCorruptFile(file, error);
+            return { schemaVersion: PERSISTENCE_SCHEMA_VERSION, results: [] };
+        }
+        if (!isRecord(parsed) ||
+            parsed.schemaVersion !== PERSISTENCE_SCHEMA_VERSION ||
+            !Array.isArray(parsed.results)) {
+            this.quarantineCorruptFile(file, new Error("invalid pending notification schema"));
+            return { schemaVersion: PERSISTENCE_SCHEMA_VERSION, results: [] };
+        }
+        const valid = parsed.results.filter(isPersistedResultEnvelope);
+        if (valid.length !== parsed.results.length) {
+            this.quarantineCorruptFile(file, new Error(`${parsed.results.length - valid.length} invalid pending notification entries`));
+        }
+        return { schemaVersion: PERSISTENCE_SCHEMA_VERSION, results: valid };
+    }
+    quarantineCorruptFile(file, error) {
+        const corruptFile = `${file}.${Date.now()}.${nanoid(6)}.corrupt`;
+        try {
+            renameSync(file, corruptFile);
+            logger.warn("notification_queue.persistence_quarantined", {
+                file,
+                corruptFile,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        catch (quarantineError) {
+            logger.warn("notification_queue.persistence_quarantine_failed", {
+                file,
+                error: quarantineError instanceof Error ? quarantineError.message : String(quarantineError),
+            });
+        }
+    }
+    reseedSequence(envelope) {
+        const key = routeSequenceKey(envelope);
+        this.sequences.set(key, Math.max(this.sequences.get(key) ?? 0, envelope.sequence));
+        this.sequenceRoutes.delete(key);
+        this.sequenceRoutes.set(key, { from: envelope.from.sessionId, to: envelope.to.sessionId });
+    }
     notify() {
         for (const listener of this.listeners) {
             try {

package/dist/tool-system/context.d.ts

@@ -215,13 +215,18 @@ export interface ExternalFileChangesRecord {
     changedFiles: string[];
     originClientMessageId?: string;
 }
-export type ToolRunYieldReason = "background_notification";
-/** Run-scoped handoff from a trusted tool to the owning turn loop. */
+export type ToolRunYieldReason = "background_notification" | "reply_committed";
+/**
+ * Run-scoped handoff from a trusted tool to the owning turn loop. Distinct
+ * reasons accumulate independently: one batch may both commit a host reply
+ * and launch background work, and the loop decides boundary precedence.
+ */
 export interface ToolRunYieldController {
     request(reason: ToolRunYieldReason): void;
     /** Inspect without clearing so the loop can prioritize an accepted steer. */
-    peek?(): ToolRunYieldReason | undefined;
-    consume(): ToolRunYieldReason | undefined;
+    peek(reason: ToolRunYieldReason): boolean;
+    /** Clear one pending reason; true if it was pending. */
+    consume(reason: ToolRunYieldReason): boolean;
 }
 export interface ToolContext {
     /** Active working directory for this Engine. */

package/dist/tool-system/external-tool-exposure.js

@@ -62,8 +62,9 @@ export const FIRST_PHASE_EXPOSURE_RATIONALE = [
     },
     // ── Delegation and state-machine exceptions ──────────────────────
     // Agent and the two plan-state tools remain structurally excluded. DriveAgent
-    // is the reviewed exception because the external host forces it into a
-    // foreground, one-level handoff with an observable result.
+    // is the reviewed exception because the child does not inherit the host
+    // bridge and background work is allowed only when the host guarantees an
+    // observable completion handoff.
     {
         tool: "Agent",
         kind: "self-contained",
@@ -78,19 +79,19 @@ export const FIRST_PHASE_EXPOSURE_RATIONALE = [
         kind: "self-contained",
         status: "exposed",
         reason: "Delegates one bounded task to an installed Codex/Claude CLI. External " +
-            "sessions force foreground execution and disable automatic background " +
-            "handoff, so the parent turn receives the result instead of losing a wake-up " +
-            "inside the native Engine queue. The child CLI does not inherit this host " +
-            "bridge, which bounds nesting at one level; the outer call still requires " +
-            "the normal DriveAgent approval.",
+            "sessions may detach it only when the Desktop host promises to drain the " +
+            "completion queue and inject a continuation into the same Session; other " +
+            "hosts fail closed and require foreground execution. The child CLI does not " +
+            "inherit this host bridge, which bounds nesting at one level; the outer call " +
+            "still requires the normal DriveAgent approval.",
     },
     {
         tool: "DriveAgentJobs",
         kind: "self-contained",
         status: "exposed",
-        reason: "Lets the runtime inspect or cancel retained DriveAgent jobs. New external " +
-            "delegations run in the foreground, but retained jobs from the same Session " +
-            "still need an observable cleanup surface.",
+        reason: "Lets the runtime inspect or cancel retained DriveAgent jobs, including " +
+            "Desktop-backed background delegations whose completion is delivered through " +
+            "the owning Session.",
     },
     {
         tool: "EnterPlanMode",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,6 +38,7 @@
   ],
   "scripts": {
     "build": "bun run clean && tsc -p tsconfig.json && bun run copy-assets",
+    "test": "bun test --timeout 30000 src",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "copy-assets": "node ../../scripts/copy-assets.mjs dist/prompt/sections src/prompt/sections/*.md && node ../../scripts/copy-assets.mjs dist/data src/data/*.json",
     "dev": "bun run copy-assets && tsc -p tsconfig.json --watch --preserveWatchOutput",

package/dist/services/notifier.d.ts

@@ -1,33 +0,0 @@
-/**
- * Notifier service — desktop/system notifications.
- *
- * Sends notifications when tasks complete, agents finish, or errors occur.
- * Falls back gracefully when no notification system is available.
- */
-export interface NotificationOptions {
-    title: string;
-    message: string;
-    sound?: boolean;
-    /** Urgency level: low, normal, critical */
-    urgency?: "low" | "normal" | "critical";
-}
-/**
- * Send a desktop notification.
- */
-export declare function notify(options: NotificationOptions): void;
-/** Escape a string for embedding inside an AppleScript double-quoted literal. */
-export declare function escapeAppleScriptString(str: string): string;
-/** Build the osascript argv (a single `-e <script>` pair). */
-export declare function buildOsascriptArgs(title: string, message: string, sound: boolean): string[];
-/** Build the notify-send argv with title/message as separate tokens. */
-export declare function buildNotifySendArgs(title: string, message: string, urgency: "low" | "normal" | "critical"): string[];
-/** Build the powershell.exe argv (a single `-Command <script>` element). */
-export declare function buildPowershellArgs(title: string, message: string): string[];
-/**
- * Send a notification that a task/agent has completed.
- */
-export declare function notifyComplete(taskName: string, duration?: number): void;
-/**
- * Send an error notification.
- */
-export declare function notifyError(context: string, error: string): void;

package/dist/services/notifier.js

@@ -1,83 +0,0 @@
-/**
- * Notifier service — desktop/system notifications.
- *
- * Sends notifications when tasks complete, agents finish, or errors occur.
- * Falls back gracefully when no notification system is available.
- */
-import { execFileSync } from "node:child_process";
-/**
- * Send a desktop notification.
- */
-export function notify(options) {
-    const { title, message, sound = false, urgency = "normal" } = options;
-    try {
-        if (process.platform === "darwin") {
-            // macOS: osascript. Pass the script as a single -e argv element via
-            // execFileSync (no shell), so title/message are never seen by the shell.
-            execFileSync("osascript", buildOsascriptArgs(title, message, sound), { timeout: 5000 });
-        }
-        else if (process.platform === "linux") {
-            // Linux: notify-send. argv keeps title/message as separate tokens.
-            execFileSync("notify-send", buildNotifySendArgs(title, message, urgency), { timeout: 5000 });
-        }
-        else if (process.platform === "win32") {
-            // Windows: PowerShell toast. The script is one -Command argv element
-            // (no outer shell); title/message are escaped for PowerShell single
-            // quotes (' → '').
-            execFileSync("powershell.exe", buildPowershellArgs(title, message), { timeout: 5000 });
-        }
-    }
-    catch {
-        // Silently fail — notifications are best-effort
-    }
-}
-/** Escape a string for embedding inside an AppleScript double-quoted literal. */
-export function escapeAppleScriptString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, " ");
-}
-/** Build the osascript argv (a single `-e <script>` pair). */
-export function buildOsascriptArgs(title, message, sound) {
-    const soundClause = sound ? ' sound name "default"' : "";
-    const script = `display notification "${escapeAppleScriptString(message)}"` +
-        ` with title "${escapeAppleScriptString(title)}"${soundClause}`;
-    return ["-e", script];
-}
-/** Build the notify-send argv with title/message as separate tokens. */
-export function buildNotifySendArgs(title, message, urgency) {
-    return ["-u", urgency, title, message];
-}
-/** Build the powershell.exe argv (a single `-Command <script>` element). */
-export function buildPowershellArgs(title, message) {
-    const esc = (s) => s.replace(/'/g, "''").replace(/\n/g, " ");
-    const ps = [
-        "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null",
-        "$xml = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)",
-        "$text = $xml.GetElementsByTagName('text')",
-        `$text[0].AppendChild($xml.CreateTextNode('${esc(title)}')) | Out-Null`,
-        `$text[1].AppendChild($xml.CreateTextNode('${esc(message)}')) | Out-Null`,
-        "$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)",
-        "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('CodeShell').Show($toast)",
-    ].join("; ");
-    return ["-NoProfile", "-Command", ps];
-}
-/**
- * Send a notification that a task/agent has completed.
- */
-export function notifyComplete(taskName, duration) {
-    const durationStr = duration ? ` (${(duration / 1000).toFixed(1)}s)` : "";
-    notify({
-        title: "Code Shell",
-        message: `✓ ${taskName} completed${durationStr}`,
-        sound: true,
-    });
-}
-/**
- * Send an error notification.
- */
-export function notifyError(context, error) {
-    notify({
-        title: "Code Shell Error",
-        message: `✗ ${context}: ${error.slice(0, 100)}`,
-        urgency: "critical",
-    });
-}