@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/web-ui/local-runtime/learning-notifications.js

@@ -12,7 +12,7 @@ export function createLearningChangeNotifier(realtime) {
             });
         }
         catch {
-            // Persisted conversations and proposal status are fetched on reconnect.
+            // Persisted conversations and learning status are fetched on reconnect.
         }
         if (event)
             notifyWorkspace(environmentId, ["sessions"]);

package/dist/src/web-ui/local-runtime/learning-routes.js

@@ -1,7 +1,6 @@
 import { acceptConfigMutationRequest } from "./config-mutation-request.js";
 import { sendJson } from "./http.js";
 import { readLearningPreferencesInput } from "../../runtime/local-host/learning-preferences-input.js";
-import { isLearningEventId } from "../../runtime/local-host/learning-events.js";
 export class PassiveLearningRoutes {
     resolveService;
     constructor(resolveService) {
@@ -67,25 +66,6 @@ export class PassiveLearningRoutes {
             });
             return;
         }
-        if (input.segments[2] === "proposals") {
-            if (input.method !== "DELETE") {
-                sendLearningMethodNotAllowed(input.response, "DELETE");
-                return;
-            }
-            const id = input.segments[3];
-            if (!isLearningEventId(id)) {
-                sendJson(input.response, 400, {
-                    ok: false,
-                    error: "passive_learning_proposal_invalid",
-                });
-                return;
-            }
-            if (!service.dismissProposal)
-                throw new Error("passive_learning_unavailable");
-            await service.dismissProposal(id);
-            sendJson(input.response, 200, { ok: true });
-            return;
-        }
         if (input.route === "runtime/learning/pending") {
             if (input.method !== "DELETE") {
                 sendLearningMethodNotAllowed(input.response, "DELETE");
@@ -139,8 +119,6 @@ function isLearningRoute(segments) {
         return segments.length === 3;
     if (segments[2] === "candidates")
         return segments.length === 3;
-    if (segments[2] === "proposals")
-        return segments.length === 4;
     if (segments[2] !== "batches")
         return false;
     return segments.length === 3 || segments.length === 4;

package/dist/src/web-ui/local-runtime/request-execution.js

@@ -1,8 +1,10 @@
+import { isAutomationSessionLockedError } from "../../sessions/automation-session-origin.js";
 import { createRequestSteeringInbox, } from "../../runtime/request/request-steering.js";
 import { getNumber, getString, sendJson } from "./http.js";
 import { PendingToolApprovals } from "./pending-tool-approvals.js";
 import { createWorkspaceChangeNotifier } from "./workspace-notifications.js";
 import { attachApprovalRequest } from "./approval-request-attachment.js";
+import { publicSparkChatAdmissionFailure, resolveSparkChatRequest } from "./spark-chat-admission.js";
 function createRequestId() {
     const random = Math.random().toString(36).slice(2, 8);
     return `web-${Date.now()}-${random}`;
@@ -62,7 +64,23 @@ export class LocalRequestExecution {
             });
             return;
         }
+        try {
+            await environment.services.sessions.assertInteractiveSession?.(sessionId);
+        }
+        catch (error) {
+            if (!isAutomationSessionLockedError(error))
+                throw error;
+            sendJson(res, 409, { ok: false, error: "automation_session_locked" });
+            return;
+        }
         const requestId = createRequestId();
+        try {
+            body = await resolveSparkChatRequest(environment, sessionId, body);
+        }
+        catch (error) {
+            sendJson(res, 409, { ok: false, ...publicSparkChatAdmissionFailure(error) });
+            return;
+        }
         const requestSteering = createRequestSteeringInbox({ requestId });
         const request = {
             type: "run_request",
@@ -133,6 +151,23 @@ export class LocalRequestExecution {
         const steerId = getString(message.steerId).trim();
         const text = getString(message.text).trim();
         const active = requestId ? this.activeRequests.get(requestId) : undefined;
+        if (active) {
+            const sessions = resolveEnvironment(active.environmentId).services.sessions;
+            try {
+                await sessions.assertInteractiveSession?.(active.sessionId);
+            }
+            catch (error) {
+                if (!isAutomationSessionLockedError(error))
+                    throw error;
+                return {
+                    type: "steer_ack",
+                    requestId,
+                    steerId,
+                    accepted: false,
+                    reason: "automation_session_locked",
+                };
+            }
+        }
         const steer = active
             ? resolveEnvironment(active.environmentId).requests.steer
             : undefined;

package/dist/src/web-ui/local-runtime/session-routes.js

@@ -1,6 +1,18 @@
 import { deleteSessionWithAttachments } from "../../runtime/session/session-attachment-deletion.js";
 import { deleteSessionAttachmentsIfSupported } from "./attachment-routes.js";
 import { sendJson } from "./http.js";
+import { isSparkSession, SPARK_SESSION_ID } from "../../sessions/spark-session.js";
+async function isProtectedSparkSession(environment, sessionId) {
+    if (sessionId !== SPARK_SESSION_ID)
+        return false;
+    const session = await environment.services.sessions.getSessionById(sessionId);
+    if (!session)
+        return false;
+    return isSparkSession(session);
+}
+function isSparkChatBusy(error) {
+    return error instanceof Error && error.message === "spark_chat_busy";
+}
 export class WebSessionRoutes {
     readStates;
     notifyChanged;
@@ -56,14 +68,28 @@ export class WebSessionRoutes {
             return true;
         }
         if (method === "DELETE" && action === "messages") {
-            const result = await sessions.clearSessionMessages(sessionId);
+            const protectedSpark = await isProtectedSparkSession(environment, sessionId);
+            let result;
+            try {
+                result = await sessions.clearSessionMessages(sessionId);
+            }
+            catch (error) {
+                if (!isSparkChatBusy(error))
+                    throw error;
+                sendJson(response, 409, {
+                    ok: false, error: "spark_chat_busy",
+                    message: "Stop the active request or resolve its approval before clearing SPARK chat.",
+                });
+                return true;
+            }
             if (!result) {
                 sendJson(response, 404, { ok: false, error: "session_not_found" });
                 return true;
             }
             try {
                 await this.readStates.reset(environmentId, sessionId);
-                await deleteSessionAttachmentsIfSupported(environment, sessionId);
+                if (!protectedSpark)
+                    await deleteSessionAttachmentsIfSupported(environment, sessionId);
             }
             finally {
                 this.notifyChanged?.(environmentId, ["sessions"]);
@@ -72,6 +98,10 @@ export class WebSessionRoutes {
             return true;
         }
         if (method === "DELETE" && !action) {
+            if (await isProtectedSparkSession(environment, sessionId)) {
+                sendJson(response, 409, { ok: false, error: "spark_session_requires_clear" });
+                return true;
+            }
             try {
                 const result = await deleteSessionWithAttachments(sessions, environment.services.attachments, sessionId);
                 await this.readStates.forget(environmentId, sessionId);

package/dist/src/web-ui/local-runtime/setup-embedding-config-repository.d.ts

@@ -0,0 +1,6 @@
+import type { LongTermMemoryOnboardingConfigRepository } from "../../runtime/long-term-memory/onboarding/contracts.js";
+/** Onboarding switches memory implementations in the same guarded config write. */
+export declare function createSetupEmbeddingConfigRepository(params: {
+    rootDir: string;
+    configPath?: string;
+}): LongTermMemoryOnboardingConfigRepository;

package/dist/src/web-ui/local-runtime/setup-embedding-config-repository.js

@@ -0,0 +1,25 @@
+import { createFileLongTermMemoryOnboardingConfigRepository } from "../../runtime/adapters/long-term-memory/onboarding-config-repository.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { updatePluginSelection } from "../plugin-management-selection.js";
+/** Onboarding switches memory implementations in the same guarded config write. */
+export function createSetupEmbeddingConfigRepository(params) {
+    const repository = createFileLongTermMemoryOnboardingConfigRepository(params);
+    return Object.freeze({
+        read: () => repository.read(),
+        write(config, expectedConfig) {
+            const enablesNativeMemory = isRecord(config.longTermMemory) &&
+                config.longTermMemory.enabled === true;
+            if (!enablesNativeMemory)
+                return repository.write(config, expectedConfig);
+            // The onboarding service validates this candidate before probing and saving.
+            const current = (config.plugins ?? {});
+            const plugins = updatePluginSelection({
+                current,
+                pluginId: "memory",
+                capabilityIds: [],
+                enabled: false,
+            });
+            return repository.write({ ...config, plugins }, expectedConfig);
+        },
+    });
+}

package/dist/src/web-ui/local-runtime/setup-embedding-service.js

@@ -1,5 +1,6 @@
 import { createLocalLongTermMemoryOnboardingService } from "../../runtime/adapters/long-term-memory/onboarding-service.js";
 import { parseSetupEmbeddingInput } from "./setup-embedding-input.js";
+import { createSetupEmbeddingConfigRepository } from "./setup-embedding-config-repository.js";
 import { prepareSetupEmbeddingProvider, } from "./setup-embedding-provider.js";
 import { RuntimeSetupError } from "./runtime-setup-input.js";
 export class SetupEmbeddingFailure extends Error {
@@ -34,6 +35,7 @@ export class SetupEmbeddingService {
             const service = createLocalLongTermMemoryOnboardingService({
                 ...options,
                 providerAdapters: this.options.providerAdapters,
+                repository: createSetupEmbeddingConfigRepository(options),
             });
             const result = await service.enable({
                 providerId: prepared.providerId,

package/dist/src/web-ui/local-runtime/spark-chat-admission.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeEnvironment, JsonObject } from "./contracts.js";
+export declare function publicSparkChatAdmissionFailure(error: unknown): {
+    error: string;
+    message: string;
+};
+/** A marked companion uses the owner's current settings, never a stale tab's defaults. */
+export declare function resolveSparkChatRequest(environment: RuntimeEnvironment, sessionId: string, body: JsonObject): Promise<JsonObject>;

package/dist/src/web-ui/local-runtime/spark-chat-admission.js

@@ -0,0 +1,37 @@
+import { isSparkSession, SPARK_SESSION_ID } from "../../sessions/spark-session.js";
+import { loadSparkChatConfiguration } from "./spark-chat-configuration.js";
+export function publicSparkChatAdmissionFailure(error) {
+    if (error instanceof Error && error.message === "spark_chat_session_unavailable")
+        return {
+            error: error.message, message: "The SPARK conversation is unavailable. Open SPARK before sending a message.",
+        };
+    if (error instanceof Error && error.message === "spark_chat_model_required")
+        return {
+            error: error.message, message: "Choose a chat and initiative model in SPARK settings before sending a message.",
+        };
+    if (error instanceof Error && error.message === "spark_chat_model_unavailable")
+        return {
+            error: error.message, message: "The selected SPARK model is unavailable. Choose an available model in SPARK settings.",
+        };
+    return { error: "spark_chat_unavailable", message: "SPARK chat settings could not be loaded." };
+}
+/** A marked companion uses the owner's current settings, never a stale tab's defaults. */
+export async function resolveSparkChatRequest(environment, sessionId, body) {
+    if (sessionId !== SPARK_SESSION_ID)
+        return body;
+    const session = await environment.services.sessions.getSessionById(sessionId);
+    if (!session)
+        throw new Error("spark_chat_session_unavailable");
+    if (!isSparkSession(session))
+        throw new Error("spark_chat_session_unavailable");
+    const settings = await loadSparkChatConfiguration(environment.services.passiveLearning);
+    if (!settings.modelProfileId)
+        throw new Error("spark_chat_model_required");
+    if (!environment.services.config.models?.profiles?.[settings.modelProfileId])
+        throw new Error("spark_chat_model_unavailable");
+    return {
+        ...body,
+        modelPreference: { profileId: settings.modelProfileId, scope: "all" },
+        toolPermissionMode: settings.toolPermissionMode,
+    };
+}

package/dist/src/web-ui/local-runtime/spark-chat-configuration.d.ts

@@ -0,0 +1,8 @@
+import type { PassiveLearningManagement } from "../../runtime/local-host/client-learning.js";
+export declare function loadSparkChatConfiguration(learning: Pick<PassiveLearningManagement, "status">): Promise<{
+    toolPermissionMode: import("../../capabilities/tool-permission-mode.js").ToolPermissionMode;
+    modelProfileId: string | null;
+}>;
+export declare function readSparkChatConfigurationUpdate(body: Record<string, unknown> | null): {
+    sparkToolPermissionMode: import("../../capabilities/tool-permission-mode.js").ToolPermissionMode;
+};

package/dist/src/web-ui/local-runtime/spark-chat-configuration.js

@@ -0,0 +1,16 @@
+import { readSparkToolPermissionMode } from "../../runtime/passive-learning/spark-chat-preferences.js";
+export async function loadSparkChatConfiguration(learning) {
+    const { preferences } = await learning.status();
+    return {
+        toolPermissionMode: readSparkToolPermissionMode(preferences.sparkToolPermissionMode),
+        modelProfileId: preferences.proactiveModelProfileId ?? preferences.modelProfileId ?? null,
+    };
+}
+export function readSparkChatConfigurationUpdate(body) {
+    if (!body || body.toolPermissionMode === undefined)
+        throw new Error("spark_chat_preferences_invalid");
+    const allowed = ["environment", "environmentId", "toolPermissionMode"];
+    if (Object.keys(body).some((key) => !allowed.includes(key)))
+        throw new Error("spark_chat_preferences_invalid");
+    return { sparkToolPermissionMode: readSparkToolPermissionMode(body.toolPermissionMode) };
+}

package/dist/src/web-ui/local-runtime/spark-chat-handoff.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeEnvironment } from "./contracts.js";
+import type { SparkChatRouteRequest } from "./spark-chat-routes.js";
+import type { WorkspaceChangeNotifier } from "./workspace-notifications.js";
+export declare function handleSparkChatHandoff(input: SparkChatRouteRequest, resolveEnvironment: (id: string) => RuntimeEnvironment, notify?: WorkspaceChangeNotifier): Promise<boolean>;

package/dist/src/web-ui/local-runtime/spark-chat-handoff.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { isAssistantInitiativeMessage } from "../../sessions/assistant-initiative.js";
+import { toSnapshotMessage } from "../../sessions/record/projection.js";
+import { isSparkSession, SPARK_SESSION_ID } from "../../sessions/spark-session.js";
+import { isSparkHandoffBrief } from "../../sessions/spark-handoff-brief.js";
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { sendJson } from "./http.js";
+const failures = {
+    spark_handoff_reference_invalid: { status: 400, message: "The SPARK message reference is invalid. Refresh the chat and try again." },
+    spark_handoff_source_unavailable: { status: 409, message: "This SPARK insight is no longer in the chat. Refresh the chat to see the current messages." },
+    spark_handoff_brief_unavailable: { status: 409, message: "This older SPARK insight does not have saved context for a new session." },
+    spark_handoff_target_conflict: { status: 409, message: "The session for this insight was cleared or changed and cannot be reopened from this message." },
+    spark_handoff_unavailable: { status: 503, message: "Opening a session from SPARK is unavailable in this environment." },
+    spark_handoff_failed: { status: 500, message: "The session could not be opened. Try again." },
+};
+function readMessageReference(body) {
+    const input = body?.message;
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("spark_handoff_reference_invalid");
+    const value = input;
+    const validId = typeof value.id === "string" && value.id.length > 0 && value.id.length <= 200;
+    const validTimestamp = typeof value.createdAt === "number" && Number.isFinite(value.createdAt);
+    const validRequest = value.requestId === null || (typeof value.requestId === "string" && value.requestId.length > 0 && value.requestId.length <= 200);
+    if (!validId || !validTimestamp || !validRequest)
+        throw new Error("spark_handoff_reference_invalid");
+    return { id: value.id, createdAt: value.createdAt, requestId: value.requestId };
+}
+function findSourceMessage(session, reference) {
+    if (!session || !isSparkSession(session))
+        throw new Error("spark_handoff_source_unavailable");
+    const message = session.messages.find((candidate) => {
+        if (!isAssistantInitiativeMessage(candidate))
+            return false;
+        const projected = toSnapshotMessage(session.id, candidate, session.requests ?? []);
+        return String(projected.id) === reference.id && projected.createdAt === reference.createdAt && projected.requestId === reference.requestId;
+    });
+    if (!message)
+        throw new Error("spark_handoff_source_unavailable");
+    return message;
+}
+function handoffFailure(error) {
+    const original = error instanceof Error ? error.message : "";
+    const deleted = !!error && typeof error === "object" && "code" in error && error.code === "session_deleted";
+    if (deleted || original === "assistant_conversation_identity_conflict")
+        return "spark_handoff_target_conflict";
+    return Object.hasOwn(failures, original) ? original : "spark_handoff_failed";
+}
+export async function handleSparkChatHandoff(input, resolveEnvironment, notify) {
+    if (input.route !== "runtime/spark/chat/sessions")
+        return false;
+    input.response.setHeader("cache-control", "no-store");
+    if (input.method !== "POST") {
+        input.response.setHeader("allow", "POST");
+        sendJson(input.response, 405, { ok: false, error: "method_not_allowed" });
+        return true;
+    }
+    if (!acceptConfigMutationRequest(input.request, input.response))
+        return true;
+    try {
+        const reference = readMessageReference(input.body);
+        const { sessions } = resolveEnvironment(input.environmentId).services;
+        const source = findSourceMessage(await sessions.getSessionById(SPARK_SESSION_ID), reference);
+        const initiative = source.initiative;
+        const brief = initiative.handoffBrief;
+        const title = initiative.handoffTitle;
+        const validTitle = typeof title === "string" && title.trim().length > 0 && title.length <= 160;
+        if (!isSparkHandoffBrief(brief) || !validTitle)
+            throw new Error("spark_handoff_brief_unavailable");
+        if (!sessions.createAssistantConversation)
+            throw new Error("spark_handoff_unavailable");
+        const identity = createHash("sha256").update(initiative.proposalId).digest("hex").slice(0, 32);
+        const session = await sessions.createAssistantConversation(`spark-work-${identity}`, { title, content: brief, initiative });
+        if (session.kind || session.automationOrigin)
+            throw new Error("spark_handoff_target_conflict");
+        notify?.(input.environmentId, ["sessions"]);
+        sendJson(input.response, 200, { ok: true, sessionId: session.id });
+    }
+    catch (error) {
+        const code = handoffFailure(error);
+        const failure = failures[code];
+        sendJson(input.response, failure.status, { ok: false, error: code, message: failure.message });
+    }
+    return true;
+}

package/dist/src/web-ui/local-runtime/spark-chat-routes.d.ts

@@ -0,0 +1,19 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RuntimeEnvironment, JsonObject } from "./contracts.js";
+import type { WebSessionReadStates } from "../session-read-state/service.js";
+import type { WorkspaceChangeNotifier } from "./workspace-notifications.js";
+export type SparkChatRouteRequest = {
+    method: string;
+    route: string;
+    body: JsonObject | null;
+    environmentId: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+};
+export declare class SparkChatRoutes {
+    private readonly environment;
+    private readonly reads;
+    private readonly notify?;
+    constructor(environment: (id: string) => RuntimeEnvironment, reads: WebSessionReadStates, notify?: WorkspaceChangeNotifier | undefined);
+    handle(input: SparkChatRouteRequest): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/spark-chat-routes.js

@@ -0,0 +1,62 @@
+import { ensureSparkSession } from "../../sessions/spark-session.js";
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { loadSparkChatConfiguration, readSparkChatConfigurationUpdate } from "./spark-chat-configuration.js";
+import { sendJson } from "./http.js";
+import { handleSparkChatHandoff } from "./spark-chat-handoff.js";
+export class SparkChatRoutes {
+    environment;
+    reads;
+    notify;
+    constructor(environment, reads, notify) {
+        this.environment = environment;
+        this.reads = reads;
+        this.notify = notify;
+    }
+    async handle(input) {
+        if (await handleSparkChatHandoff(input, this.environment, this.notify))
+            return true;
+        if (!["runtime/spark/chat", "runtime/spark/chat/read"].includes(input.route))
+            return false;
+        input.response.setHeader("cache-control", "no-store");
+        const readReceipt = input.route.endsWith("/read");
+        const allowed = readReceipt ? ["POST"] : ["GET", "PUT"];
+        if (!allowed.includes(input.method)) {
+            input.response.setHeader("allow", allowed.join(", "));
+            sendJson(input.response, 405, { ok: false, error: "method_not_allowed" });
+            return true;
+        }
+        if (input.method !== "GET" && !acceptConfigMutationRequest(input.request, input.response))
+            return true;
+        try {
+            const update = input.method === "PUT" ? readSparkChatConfigurationUpdate(input.body) : undefined;
+            const environment = this.environment(input.environmentId);
+            const session = await ensureSparkSession(environment.services.sessions);
+            if (readReceipt) {
+                const readState = await this.reads.markVisible(input.environmentId, session.id, input.body?.visibleMessageIds, input.body?.readGeneration, input.body?.visibleMessages);
+                this.notify?.(input.environmentId, ["sessions"]);
+                sendJson(input.response, 200, { ok: true, readState });
+                return true;
+            }
+            if (update)
+                await environment.services.passiveLearning.configure(update);
+            const configuration = await loadSparkChatConfiguration(environment.services.passiveLearning);
+            const snapshot = await environment.services.sessions.getSessionSnapshot(session.id, { includeRequests: true });
+            if (!snapshot)
+                throw new Error("spark_chat_unavailable");
+            sendJson(input.response, 200, {
+                ok: true, sessionId: session.id, ...configuration, snapshot,
+                readState: await this.reads.project(input.environmentId, snapshot),
+            });
+            return true;
+        }
+        catch (error) {
+            const code = error instanceof Error ? error.message : "spark_chat_unavailable";
+            const invalid = ["spark_chat_preferences_invalid", "invalid_spark_tool_permission_mode", "visible_message_ids_invalid", "visible_message_receipts_invalid"].includes(code);
+            const stale = ["read_generation_changed", "visible_message_receipt_stale"].includes(code);
+            sendJson(input.response, invalid ? 400 : 409, {
+                ok: false, error: invalid || stale ? code : "spark_chat_unavailable",
+            });
+            return true;
+        }
+    }
+}

package/dist/src/web-ui/local-runtime-backend.d.ts

@@ -17,5 +17,9 @@ export declare class LocalRuntimeWebBackend {
     notifyHostConnectionChanged(): void;
     start(environmentIds: readonly string[]): Promise<void>;
     environmentConfig(): import("./environment-config.js").WebUiEnvironmentConfig | undefined;
+    nativePermissions(environmentId: string): Readonly<{
+        status(): Promise<import("../computer-access/native-permission-contract.js").NativePermissionStatus>;
+        prepare(input: import("../computer-access/native-permission-contract.js").NativePermissionInput): Promise<import("../computer-access/native-permission-contract.js").NativePermissionResult>;
+    }> | undefined;
     stop(): Promise<void>;
 }

package/dist/src/web-ui/local-runtime-backend.js

@@ -108,6 +108,9 @@ export class LocalRuntimeWebBackend {
     environmentConfig() {
         return this.environments.environmentConfig();
     }
+    nativePermissions(environmentId) {
+        return this.environments.existingNativePermissions(environmentId);
+    }
     async stop() {
         await this.notifications.stop();
         await this.environments.stop();

package/dist/src/web-ui/notifications/automation-event-projection.d.ts

@@ -0,0 +1,3 @@
+import type { WebNotification } from "./contracts.js";
+/** A committed scheduler transition points to its canonical run report. */
+export declare function projectAutomationRunNotificationEvent(event: Record<string, unknown>, now: number): WebNotification | undefined;

package/dist/src/web-ui/notifications/automation-event-projection.js

@@ -0,0 +1,57 @@
+import { createHash } from "node:crypto";
+import { eventText, hasNotificationIdentity, notificationBody } from "./event-fields.js";
+const TERMINAL_TITLES = {
+    succeeded: "Automation completed",
+    completed_with_skips: "Automation completed with skipped steps",
+    failed: "Automation failed",
+    cancelled: "Automation stopped",
+    interrupted: "Automation interrupted",
+    missed: "Automation run missed",
+};
+function terminalAutomationStatus(value) {
+    return Object.hasOwn(TERMINAL_TITLES, value);
+}
+function automationNotificationPhase(name) {
+    if (name === "automation.run.started")
+        return "started";
+    if (name === "automation.run.finished")
+        return "finished";
+    return null;
+}
+/** A committed scheduler transition points to its canonical run report. */
+export function projectAutomationRunNotificationEvent(event, now) {
+    if (event.type !== "event")
+        return;
+    const phase = automationNotificationPhase(event.name);
+    if (!phase)
+        return;
+    const status = eventText(event.status);
+    if (phase === "started" && status !== "running")
+        return;
+    if (phase === "finished" && !terminalAutomationStatus(status))
+        return;
+    const environmentId = eventText(event.environment) || eventText(event.environmentId);
+    const automationId = eventText(event.automationId);
+    const runId = eventText(event.runId);
+    if (![environmentId, automationId, runId].every(hasNotificationIdentity))
+        return;
+    const name = notificationBody(eventText(event.title)) || "Automation";
+    const title = phase === "started" ? "Automation started" : TERMINAL_TITLES[status];
+    const parameters = new URLSearchParams({ environment: environmentId, automation: automationId, run: runId });
+    const id = createHash("sha256")
+        .update(JSON.stringify([environmentId, "automation", runId, phase]))
+        .digest("hex");
+    return {
+        id,
+        kind: "automation",
+        title,
+        body: name,
+        createdAt: now,
+        readAt: null,
+        environmentId,
+        automationId,
+        runId,
+        sourceUrl: `/automations?${parameters}`,
+        delivery: { status: "pending" },
+    };
+}

package/dist/src/web-ui/notifications/contracts.d.ts

@@ -1,21 +1,35 @@
-export type NotificationKind = "reply" | "failure" | "approval" | "proposal";
+import type { SessionKind } from "../../sessions/spark-session.js";
+export type NotificationKind = "reply" | "failure" | "approval" | "proposal" | "automation";
 export type NotificationDelivery = {
     status: "pending" | "submitted" | "disabled" | "unavailable" | "failed" | "unknown";
     error?: string;
 };
-export type WebNotification = {
+type NotificationDetails = {
     id: string;
-    kind: NotificationKind;
     title: string;
     body: string;
     createdAt: number;
     readAt: number | null;
     environmentId: string;
-    sessionId: string;
-    requestId?: string;
     sourceUrl: string;
     delivery: NotificationDelivery;
 };
+export type WebNotification = NotificationDetails & ({
+    kind: "automation";
+    automationId: string;
+    runId: string;
+    sessionId?: never;
+    sessionKind?: never;
+    requestId?: never;
+} | {
+    kind: Exclude<NotificationKind, "automation">;
+    sessionId: string;
+    /** Copied only from the canonical persisted session. */
+    sessionKind?: SessionKind;
+    requestId?: string;
+    automationId?: never;
+    runId?: never;
+});
 export type NotificationPreferences = {
     desktopEnabled: boolean;
     kinds: Record<NotificationKind, boolean>;
@@ -49,3 +63,4 @@ export type NotificationDesktopState = {
 export declare class NotificationInputError extends Error {
 }
 export declare function defaultNotificationPreferences(): NotificationPreferences;
+export {};

package/dist/src/web-ui/notifications/contracts.js

@@ -3,6 +3,12 @@ export class NotificationInputError extends Error {
 export function defaultNotificationPreferences() {
     return {
         desktopEnabled: true,
-        kinds: { reply: true, failure: true, approval: true, proposal: true },
+        kinds: {
+            reply: true,
+            failure: true,
+            approval: true,
+            proposal: true,
+            automation: true,
+        },
     };
 }

package/dist/src/web-ui/notifications/conversation-source.d.ts

@@ -0,0 +1,6 @@
+import type { SessionRecord } from "../../sessions/types.js";
+export type NotificationSession = Partial<Pick<SessionRecord, "kind" | "messages" | "requests">> & {
+    automationOrigin?: unknown;
+};
+/** Navigation follows the stored session kind; titles never identify SPARK. */
+export declare function conversationNotificationSource(environmentId: string, sessionId: string, event: Record<string, unknown>, persisted?: NotificationSession | null): string;