@capybara-hq/kernel 0.1.0-rc.24 → 0.1.0-rc.26

package/dist/schedules/scan.job.js

@@ -8,31 +8,22 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { randomUUID } from "node:crypto";
-import { getQueueToken } from "@nestjs/bullmq";
 import { Inject, Injectable } from "@nestjs/common";
-import { sql } from "kysely";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
-import { afterCommit } from "../infra/database/after-commit.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { LockService } from "../infra/lock/lock.service.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import { LockedCron } from "../infra/schedule/locked-cron.decorator.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
-import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
 import { readScheduleSettings } from "./effective-settings.js";
-import { SCHED_SCAN_JOB, schedFireJob } from "./job-ids.js";
+import { oweSchedFire, oweSchedSettleUnfired, SCHED_SCAN_JOB } from "./job-ids.js";
 import { pauseTaskIn } from "./pause.js";
-import { lockTaskRow, ScheduledTaskRunTracker } from "./run-tracker.js";
 import { scanStep } from "./schedule-math.js";
 import { ScheduledTaskStore } from "./store.js";
 /** Due tasks per scan; what is left waits for the next minute. */
 const MAX_TASKS = 2000;
-/** A pending task run never fired this long after its tick: its fire job is enqueued again. */
-const REPAIR_AFTER_MS = 10 * 60_000;
-/** ... and this long after its tick it is given up (`skipped`, `missed`). */
-const GIVE_UP_AFTER_MS = 60 * 60_000;
-const REPAIR_BATCH = 100;
 /**
  * The schedule math could not evaluate a due task's stored trigger (its transaction rolled back);
  * the scan pauses it. Only the math raises it: a database error fails the scan pass instead (the
@@ -51,32 +42,28 @@ class TaskScanFailed extends Error {
  * same task): the ticks missed outside the org's `catchUpWindowMinutes` become one `skipped` run
  * (`missed`, at the first missed tick), the latest tick in the window gets its run (the unique
  * `(task_id, scheduled_for)` key makes a second insert a no-op), `next_run_at` moves to the next
- * tick plus the task's jitter (or a `once` task ends, or one past its `expires_at`), and after the
- * commit `sched-fire-<taskRunId>` is enqueued. A task whose stored trigger the schedule math cannot
- * evaluate is paused (`invalid_schedule`) instead of failing the scan; a database error fails the
- * pass (the next minute retries) and pauses nothing.
- *
- * Then the repair: a run still `pending` and unfired 10 minutes after its tick has its fire job
- * enqueued again, and is given up (`skipped`, `missed`) after an hour; a run fired an hour ago and
- * still `pending` (its start failed for good) goes through the run tracker's check, which links,
- * settles or releases it, so a `once` task's last run never stays pending.
+ * tick plus the task's jitter (or a `once` task ends, or one past its `expires_at`), and the same
+ * transaction owes `sched-fire-<taskRunId>` (transactional outbox spec §8.1), so a written tick is
+ * never left unfired and the scan needs no repair of lost fire jobs (a fire delivered too late
+ * marks its tick missed itself, `ScheduledTaskFirer`), and the run's unfired settle check (a fire
+ * job that failed for good before its claim: the tick is missed, `job-ids.ts`). A task whose stored
+ * trigger the schedule math cannot evaluate is paused (`invalid_schedule`) instead of failing the
+ * scan; a database error fails the pass (the next minute retries) and pauses nothing.
  */
 let ScheduledTaskScanJob = class ScheduledTaskScanJob {
     kdb;
     txHost;
     config;
     store;
-    tracker;
-    maintenance;
+    outbox;
     lockService;
     log;
-    constructor(kdb, txHost, config, store, tracker, maintenance, lockService, log) {
+    constructor(kdb, txHost, config, store, outbox, lockService, log) {
         this.kdb = kdb;
         this.txHost = txHost;
         this.config = config;
         this.store = store;
-        this.tracker = tracker;
-        this.maintenance = maintenance;
+        this.outbox = outbox;
         this.lockService = lockService;
         this.log = log;
     }
@@ -86,41 +73,32 @@ let ScheduledTaskScanJob = class ScheduledTaskScanJob {
     async scan() {
         await this.scanAt(new Date());
     }
-    /**
-     * One scan as of `now` (tests pass their own); returns how many due tasks it handled. The repair
-     * runs even when the scan loop failed (its error is rethrown afterwards). `repairBatch`: how many
-     * rows each repair step takes (tests pass a small one).
-     */
-    async scanAt(now, repairBatch = REPAIR_BATCH) {
+    /** One scan as of `now` (tests pass their own); returns how many due tasks it handled. */
+    async scanAt(now) {
         const settings = new Map();
         let total = 0;
-        try {
-            for (; total < MAX_TASKS; total++) {
-                try {
-                    if (!(await this.scanOne(now, settings)))
-                        break;
-                }
-                catch (err) {
-                    if (!(err instanceof TaskScanFailed))
-                        throw err;
-                    // one task that cannot be advanced must not hold the others back every minute
-                    this.log.error("scheduled task cannot be advanced; paused", {
-                        taskId: err.taskId,
-                        err: err.cause,
-                    });
-                    await this.quarantine(err.taskId);
-                }
+        for (; total < MAX_TASKS; total++) {
+            try {
+                if (!(await this.scanOne(now, settings)))
+                    break;
+            }
+            catch (err) {
+                if (!(err instanceof TaskScanFailed))
+                    throw err;
+                // one task that cannot be advanced must not hold the others back every minute
+                this.log.error("scheduled task cannot be advanced; paused", {
+                    taskId: err.taskId,
+                    err: err.cause,
+                });
+                await this.quarantine(err.taskId);
             }
-        }
-        finally {
-            await this.repair(now, repairBatch);
         }
         return total;
     }
     /**
-     * One due task in its own transaction (a task whose trigger cannot be evaluated rolls back
-     * alone and is paused, so it cannot block the others): locked with `SKIP LOCKED`, so replicas take different tasks. False
-     * when no task is due.
+     * One due task in its own transaction (a task whose trigger cannot be evaluated rolls back alone
+     * and is paused, so it cannot block the others): locked with `SKIP LOCKED`, so replicas take
+     * different tasks. False when no task is due.
      */
     async scanOne(now, settings) {
         const t = this.db;
@@ -134,8 +112,8 @@ let ScheduledTaskScanJob = class ScheduledTaskScanJob {
         }
         const fired = await this.advance(t, task, now, s.catchUpWindowMinutes);
         if (fired !== null) {
-            const id = fired;
-            afterCommit(() => this.enqueue([id]));
+            await oweSchedFire(this.outbox, fired.id, task.orgId);
+            await oweSchedSettleUnfired(this.outbox, fired.id, task.orgId, fired.scheduledFor, s.catchUpWindowMinutes);
         }
         return true;
     }
@@ -143,7 +121,7 @@ let ScheduledTaskScanJob = class ScheduledTaskScanJob {
     async quarantine(taskId) {
         await pauseTaskIn(this.db, taskId, "invalid_schedule", null);
     }
-    /** One due task (see the class); returns the id of the run to fire, if any. */
+    /** One due task (see the class); returns the run to fire, if any. */
     async advance(t, task, now, catchUpWindowMinutes) {
         // the schedule math alone may mark the task broken; database errors fail this pass only
         let step;
@@ -178,7 +156,7 @@ let ScheduledTaskScanJob = class ScheduledTaskScanJob {
                 scheduledFor: step.fire,
                 trial: false,
             });
-            fired = run?.id ?? null;
+            fired = run ?? null;
         }
         const patch = step.end === "done"
             ? { status: "ended", nextRunAt: null }
@@ -188,86 +166,6 @@ let ScheduledTaskScanJob = class ScheduledTaskScanJob {
         await this.store.updateTask(t, task.id, patch);
         return fired;
     }
-    /** Enqueues the fire jobs (after the commit; a failure is repaired by a later scan). */
-    async enqueue(ids) {
-        for (const id of ids) {
-            const job = schedFireJob(id);
-            try {
-                await this.maintenance.add(job.name, job.data, job.opts);
-            }
-            catch (err) {
-                this.log.warn("enqueueing a scheduled task run failed", { taskRunId: id, err });
-            }
-        }
-    }
-    /** Lost fire jobs (see the class). */
-    async repair(now, batch) {
-        const stale = await this.db
-            .selectFrom("scheduled_task_runs")
-            .select(["id", "scheduled_for"])
-            .where("status", "=", "pending")
-            .where("fired_at", "is", null)
-            .where("scheduled_for", "<", new Date(now.getTime() - REPAIR_AFTER_MS))
-            .orderBy("scheduled_for")
-            .limit(batch)
-            .execute();
-        const retry = [];
-        const lost = [];
-        for (const r of stale) {
-            const at = r.scheduled_for instanceof Date ? r.scheduled_for : new Date(r.scheduled_for);
-            (now.getTime() - at.getTime() > GIVE_UP_AFTER_MS ? lost : retry).push(r.id);
-        }
-        for (const id of lost)
-            await this.giveUp(id);
-        await this.enqueue(retry);
-        // the least recently rechecked first, so runs still in flight do not starve the others
-        const started = await this.db
-            .selectFrom("scheduled_task_runs")
-            .select("id")
-            .where("status", "=", "pending")
-            .where("fired_at", "<", new Date(now.getTime() - GIVE_UP_AFTER_MS))
-            .orderBy(sql `rechecked_at NULLS FIRST`)
-            .orderBy("scheduled_for")
-            .limit(batch)
-            .execute();
-        for (const r of started)
-            await this.recheck(r.id, now);
-    }
-    /** A run never fired an hour after its tick: given up, task row first (the one lock order). */
-    async giveUp(taskRunId) {
-        const owner = await this.db
-            .selectFrom("scheduled_task_runs")
-            .select("task_id")
-            .where("id", "=", taskRunId)
-            .executeTakeFirst();
-        if (!owner)
-            return;
-        await lockTaskRow(this.db, owner.task_id);
-        await this.db
-            .updateTable("scheduled_task_runs")
-            .set({ status: "skipped", skip_reason: "missed", error: "The run could not be started" })
-            .where("id", "=", taskRunId)
-            .where("status", "=", "pending")
-            .where("fired_at", "is", null)
-            .execute();
-    }
-    /**
-     * A started run still pending long after: the tracker links, settles or releases it; one still
-     * in flight is stamped (`rechecked_at`) and goes to the back of the next rechecks.
-     */
-    async recheck(taskRunId, now) {
-        const run = await this.store.updateRun(this.db, taskRunId, {});
-        if (run?.status !== "pending")
-            return;
-        // inFlightIn takes the task row before the run (the one lock order)
-        if (await this.tracker.inFlightIn(run, now)) {
-            await this.db
-                .updateTable("scheduled_task_runs")
-                .set({ rechecked_at: now })
-                .where("id", "=", taskRunId)
-                .execute();
-        }
-    }
 };
 __decorate([
     LockedCron("* * * * *", { name: SCHED_SCAN_JOB })
@@ -278,21 +176,14 @@ __decorate([
 __decorate([
     Transactional()
 ], ScheduledTaskScanJob.prototype, "quarantine", null);
-__decorate([
-    Transactional()
-], ScheduledTaskScanJob.prototype, "giveUp", null);
-__decorate([
-    Transactional()
-], ScheduledTaskScanJob.prototype, "recheck", null);
 ScheduledTaskScanJob = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(TransactionHost)),
     __param(2, Inject(KernelConfigService)),
     __param(3, Inject(ScheduledTaskStore)),
-    __param(4, Inject(ScheduledTaskRunTracker)),
-    __param(5, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME))),
-    __param(6, Inject(LockService)),
-    __param(7, Inject(KERNEL_LOGGER))
+    __param(4, Inject(OutboxService)),
+    __param(5, Inject(LockService)),
+    __param(6, Inject(KERNEL_LOGGER))
 ], ScheduledTaskScanJob);
 export { ScheduledTaskScanJob };

package/dist/schedules/scheduled-tasks.service.d.ts

@@ -1,4 +1,3 @@
-import type { Queue } from "bullmq";
 import { AgentLookup } from "../agents/agent-lookup.js";
 import type { ModelRef } from "../agents/definition.js";
 import { ConversationAccess } from "../conversations/access.js";
@@ -7,6 +6,7 @@ import { ExtensionRegistry } from "../extensions/registry.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import { DevicePolicyService } from "../local-devices/device-policy.service.js";
 import type { KernelLogger } from "../log.js";
 import { OrgLock } from "../orgs/org-lock.js";
@@ -198,8 +198,8 @@ export declare class ScheduledTasksService {
     /** A task's model must resolve for the org and declare its effort (as a message's switch). */
     private readonly providers;
     private readonly log;
-    /** "Run now" enqueues the fire job (consumed by the worker role). */
-    private readonly maintenance;
+    /** "Run now" owes the fire job (consumed by the worker role). */
+    private readonly outbox;
     /** Network grants: the org's effective egress (network ask-to-allow spec §8.1). */
     private readonly sandbox;
     /** Network grants: the task's device's local policy summary (`remoteGrants`). */
@@ -207,8 +207,8 @@ export declare class ScheduledTasksService {
     constructor(db: KernelDb, txHost: TransactionHost, config: Pick<KernelConfigService, "get">, store: ScheduledTaskStore, orgLock: Pick<OrgLock, "lockAndAuthorize">, agents: Pick<AgentLookup, "get">, access: Pick<ConversationAccess, "isAccessible">, tools: Pick<ToolRegistry, "forAgent">, extensions: Pick<ExtensionRegistry, "list">, 
     /** A task's model must resolve for the org and declare its effort (as a message's switch). */
     providers: Pick<ProviderRegistry, "resolve">, log: Pick<KernelLogger, "warn">, 
-    /** "Run now" enqueues the fire job (consumed by the worker role). */
-    maintenance: Pick<Queue, "add">, 
+    /** "Run now" owes the fire job (consumed by the worker role). */
+    outbox: Pick<OutboxService, "add">, 
     /** Network grants: the org's effective egress (network ask-to-allow spec §8.1). */
     sandbox: Pick<SandboxService, "ceilingLimits" | "devicePolicy">, 
     /** Network grants: the task's device's local policy summary (`remoteGrants`). */
@@ -301,7 +301,7 @@ export declare class ScheduledTasksService {
     /**
      * "Run now" (spec §6), creator only: a task run for the request time, outside the schedule (no
      * unique-key conflict with a tick, and `next_run_at` does not move), fired at once through the
-     * fire job after the commit. `trial`: an attended trial run whose approvals become the task's
+     * fire job its transaction owes. `trial`: an attended trial run whose approvals become the task's
      * grants (§7). Counted in the rate limit like any run. An ended task cannot run; a paused one
      * can (only its creator gets here: the run is `manual`, which the fire's paused check lets by).
      */

package/dist/schedules/scheduled-tasks.service.js

@@ -9,7 +9,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { randomUUID } from "node:crypto";
 import { CHANNEL_EXTENSION_POINT } from "@capybara-hq/plugin-sdk";
-import { getQueueToken } from "@nestjs/bullmq";
 import { Inject, Injectable } from "@nestjs/common";
 import { AgentLookup } from "../agents/agent-lookup.js";
 import { ConversationAccess } from "../conversations/access.js";
@@ -18,16 +17,15 @@ import { ApiError } from "../errors.js";
 import { ExtensionRegistry } from "../extensions/registry.js";
 import { audit } from "../identity/audit.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
-import { afterCommit } from "../infra/database/after-commit.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
+import { OutboxService } from "../infra/outbox/outbox.service.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { DevicePolicyService } from "../local-devices/device-policy.service.js";
 import { orgAllows } from "../local-devices/network-grants.js";
 import { OrgLock } from "../orgs/org-lock.js";
 import { can, roleAtLeast } from "../orgs/roles.js";
-import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
 import { ProviderRegistry } from "../runtime/providers.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { isTimeZone } from "../time-zone.js";
@@ -36,7 +34,7 @@ import { assembleCalendar, CALENDAR_LIMITS, CALENDAR_RANGE_DAYS, CALENDAR_TASK_R
 import { readScheduleSettings } from "./effective-settings.js";
 import { grantNotAllowed, scheduleDisabled, scheduleForbidden, scheduleNotFound, targetInvalid, } from "./errors.js";
 import { grantRefusal, grantRefusalOf, isNetworkGrantKey, isPolicyGrantKey, isTierGrantKey, NETWORK_GRANT_PREFIX, NETWORK_GRANT_SPEC_HASH, networkGrantHost, networkGrantRefusal, TIER_GRANT_SPEC_HASH, tierGrantRefusal, } from "./grant-rules.js";
-import { schedFireJob } from "./job-ids.js";
+import { oweSchedFire, oweSchedSettleUnfired } from "./job-ids.js";
 import { pauseTaskIn } from "./pause.js";
 import { jitterForGap, minGapMinutes, nextTick, validateTrigger } from "./schedule-math.js";
 import { ScheduledTaskStore } from "./store.js";
@@ -75,14 +73,14 @@ let ScheduledTasksService = class ScheduledTasksService {
     extensions;
     providers;
     log;
-    maintenance;
+    outbox;
     sandbox;
     devicePolicy;
     constructor(db, txHost, config, store, orgLock, agents, access, tools, extensions, 
     /** A task's model must resolve for the org and declare its effort (as a message's switch). */
     providers, log, 
-    /** "Run now" enqueues the fire job (consumed by the worker role). */
-    maintenance, 
+    /** "Run now" owes the fire job (consumed by the worker role). */
+    outbox, 
     /** Network grants: the org's effective egress (network ask-to-allow spec §8.1). */
     sandbox, 
     /** Network grants: the task's device's local policy summary (`remoteGrants`). */
@@ -98,7 +96,7 @@ let ScheduledTasksService = class ScheduledTasksService {
         this.extensions = extensions;
         this.providers = providers;
         this.log = log;
-        this.maintenance = maintenance;
+        this.outbox = outbox;
         this.sandbox = sandbox;
         this.devicePolicy = devicePolicy;
     }
@@ -525,6 +523,8 @@ let ScheduledTasksService = class ScheduledTasksService {
             disabledTools: d.disabledTools ?? [],
             subagentTools: d.subagentTools,
             subagents: d.subagents,
+            // no conversation at hand: a web one's tools; a run elsewhere still refuses by spec.sources
+            source: "web",
         });
         const ctx = {
             role,
@@ -789,6 +789,8 @@ let ScheduledTasksService = class ScheduledTasksService {
                 disabledTools: d.disabledTools ?? [],
                 subagentTools: d.subagentTools,
                 subagents: d.subagents,
+                // no conversation at hand: a web one's tools; a run elsewhere still refuses by spec.sources
+                source: "web",
             });
             return new Map(tools.map((x) => [
                 x.key,
@@ -820,7 +822,7 @@ let ScheduledTasksService = class ScheduledTasksService {
     /**
      * "Run now" (spec §6), creator only: a task run for the request time, outside the schedule (no
      * unique-key conflict with a tick, and `next_run_at` does not move), fired at once through the
-     * fire job after the commit. `trial`: an attended trial run whose approvals become the task's
+     * fire job its transaction owes. `trial`: an attended trial run whose approvals become the task's
      * grants (§7). Counted in the rate limit like any run. An ended task cannot run; a paused one
      * can (only its creator gets here: the run is `manual`, which the fire's paused check lets by).
      */
@@ -850,10 +852,9 @@ let ScheduledTasksService = class ScheduledTasksService {
             target: task.id,
             detail: { taskRunId: run.id, trial: opts.trial },
         });
-        const job = schedFireJob(run.id);
-        afterCommit(async () => {
-            await this.maintenance.add(job.name, job.data, job.opts);
-        });
+        await oweSchedFire(this.outbox, run.id, orgId);
+        // a fire job that fails for good before its claim leaves the run to this check (`removed`)
+        await oweSchedSettleUnfired(this.outbox, run.id, orgId, run.scheduledFor, null);
         return run;
     }
     /** The live role of a member of the org; not a member → `schedule.not_found`. */
@@ -1083,6 +1084,8 @@ let ScheduledTasksService = class ScheduledTasksService {
             disabledTools: d.disabledTools ?? [],
             subagentTools: d.subagentTools,
             subagents: d.subagents,
+            // no conversation at hand: a web one's tools; a run elsewhere still refuses by spec.sources
+            source: "web",
         });
         for (const g of toolGrants) {
             const tool = tools.find((x) => x.key === g.toolKey);
@@ -1168,7 +1171,7 @@ ScheduledTasksService = __decorate([
     __param(8, Inject(ExtensionRegistry)),
     __param(9, Inject(ProviderRegistry)),
     __param(10, Inject(KERNEL_LOGGER)),
-    __param(11, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME))),
+    __param(11, Inject(OutboxService)),
     __param(12, Inject(SandboxService)),
     __param(13, Inject(DevicePolicyService))
 ], ScheduledTasksService);

package/dist/schedules/schedules.module.js

@@ -11,10 +11,8 @@ import { Inject, Module } from "@nestjs/common";
 import { AgentLookupModule } from "../agents/agent-lookup.js";
 import { ConversationAccessModule } from "../conversations/access.js";
 import { ExtensionRegistryModule } from "../extensions/registry.js";
-import { QueueModule } from "../infra/queue/queue.module.js";
 import { LocalDevicesModule } from "../local-devices/local-devices.module.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
-import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
 import { ProvidersModule } from "../runtime/providers.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
 import { ScheduleToolsPort } from "../tools/builtins/schedules.js";
@@ -53,8 +51,6 @@ SchedulesModule = __decorate([
             // network grants: the org's effective egress and the task device's policy summary
             SandboxModule,
             LocalDevicesModule,
-            // "run now" enqueues the fire job
-            QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
         ],
         providers: [ScheduledTasksService],
         exports: [ScheduledTasksService, ScheduledTaskStoreModule],

package/dist/skills/catalog.d.ts

@@ -156,13 +156,17 @@ export declare class SkillsCatalogService {
     constructor(db: KernelDb, eventLog: EventLog, log: KernelLogger, txHost: TransactionHost, config: KernelConfigService);
     /**
      * Records the run start's snapshot (see the class comment). `opts.log`: the run's logger
-     * (default the kernel logger).
+     * (default the kernel logger). False: the run had ended (a stop got there first), so nothing was
+     * appended and the run must not go on.
      */
     record(input: EffectiveSkillsInput & {
         runId: string;
     }, opts?: {
         log?: Pick<Logger, "warn" | "error">;
-    }): Promise<void>;
-    /** Under the conversation row lock, resolves the skills and appends a changed snapshot. */
+    }): Promise<boolean>;
+    /**
+     * Under the conversation row lock, resolves the skills and appends a changed snapshot; `ended`
+     * (nothing appended) when the run is terminal under the locks.
+     */
     private append;
 }

package/dist/skills/catalog.js

@@ -18,6 +18,7 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
 import { CLAUDE_CODE_TOOL_MAP } from "../runtime/context/claude-tools.js";
 import { catalogLine, sameSnapshot, } from "../runtime/context/skills.js";
+import { runEndedIn } from "../runtime/run-status.js";
 import { agentOwnSkillIds, agentSkills, builtinSkillIds, builtinSkillPlugins, } from "./usable.js";
 /**
  * The skills in effect for this conversation now, sorted by name (code point order), as
@@ -264,16 +265,25 @@ let SkillsCatalogService = class SkillsCatalogService {
     }
     /**
      * Records the run start's snapshot (see the class comment). `opts.log`: the run's logger
-     * (default the kernel logger).
+     * (default the kernel logger). False: the run had ended (a stop got there first), so nothing was
+     * appended and the run must not go on.
      */
     async record(input, opts = {}) {
         const toSeq = await this.append(input, opts.log ?? this.log);
+        if (toSeq === "ended")
+            return false;
         if (toSeq !== null)
             await this.eventLog.notify(input.conversationId, toSeq);
+        return true;
     }
-    /** Under the conversation row lock, resolves the skills and appends a changed snapshot. */
+    /**
+     * Under the conversation row lock, resolves the skills and appends a changed snapshot; `ended`
+     * (nothing appended) when the run is terminal under the locks.
+     */
     async append(input, log) {
         const last = await lockLatestCatalog(this.db.db, input.conversationId);
+        if (await runEndedIn(this.db.db, input.runId))
+            return "ended";
         const all = await resolveSkills(this.db.db, input, log);
         const resolved = forModel(all, input, log);
         const budget = this.config.get().skills.catalogBudgetChars;

package/dist/skills/changes.controller.d.ts

@@ -40,7 +40,7 @@ export declare class InboxController {
     private readonly inbox;
     constructor(inbox: InboxService);
     list(principal: Principal, org: OrgContext): Promise<InboxView>;
-    /** An org admin dismisses an org notice (`skill_renamed`) -> 204. */
+    /** An org admin dismisses an org notice -> 204. */
     dismissNotice(principal: Principal, org: OrgContext, params: z.infer<typeof NoticeParamsSchema>): Promise<void>;
 }
 export {};

package/dist/skills/changes.controller.js

@@ -86,7 +86,7 @@ let InboxController = class InboxController {
         const p = requireUser(principal);
         return this.inbox.list(org.orgId, p.account.id);
     }
-    /** An org admin dismisses an org notice (`skill_renamed`) -> 204. */
+    /** An org admin dismisses an org notice -> 204. */
     async dismissNotice(principal, org, params) {
         const p = requireUser(principal);
         await this.inbox.dismissNotice(org.orgId, p.account.id, params.id);