@capybara-hq/kernel 0.1.0-rc.23 → 0.1.0-rc.25

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,24 +17,24 @@ 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";
 import { ToolRegistry } from "../tools/registry.js";
+import { assembleCalendar, CALENDAR_LIMITS, CALENDAR_RANGE_DAYS, CALENDAR_TASK_RANGE_DAYS, calendarRunReadLimit, } from "./calendar.js";
 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";
@@ -74,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`). */
@@ -97,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;
     }
@@ -363,6 +362,58 @@ let ScheduledTasksService = class ScheduledTasksService {
         }
         return this.withLastRuns(tasks);
     }
+    /**
+     * The calendar between two instants (calendar spec §5): the runs and planned occurrences of the
+     * actor's own tasks, or with `all` (org admins only, else `forbidden`) every task of the org; with
+     * `taskId` only that task (one the actor may see, else `schedule.not_found`), never collapsed.
+     * Another creator's runs come without `conversationId`, `error` and `missingGrants` (§15 Q3).
+     * A range longer than 43 days (2 with `taskId`), or not forward, is `validation_failed`. `now`
+     * is for tests.
+     */
+    async calendar(orgId, actor, q, now = new Date(), limits = CALENDAR_LIMITS) {
+        const role = await this.liveRole(orgId, actor.accountId);
+        const manage = can(role, "schedules.manage");
+        if (q.all === true && !manage) {
+            throw new ApiError("forbidden", "Only org admins can read every scheduled task");
+        }
+        const span = q.to.getTime() - q.from.getTime();
+        const maxDays = q.taskId === undefined ? CALENDAR_RANGE_DAYS : CALENDAR_TASK_RANGE_DAYS;
+        if (!(span > 0))
+            throw new ApiError("validation_failed", "from must be before to");
+        if (span > maxDays * DAY_MS) {
+            throw new ApiError("validation_failed", `The range is at most ${maxDays} days${q.taskId === undefined ? "" : " with taskId"}`);
+        }
+        const t = this.db.db;
+        let tasks;
+        if (q.taskId !== undefined) {
+            const task = await this.store.getTask(t, orgId, q.taskId);
+            if (!task || (task.accountId !== actor.accountId && !manage))
+                throw scheduleNotFound();
+            tasks = [task];
+        }
+        else {
+            tasks =
+                q.all === true
+                    ? await this.store.listForOrg(t, orgId)
+                    : await this.store.listForAccount(t, orgId, actor.accountId);
+        }
+        const runs = await this.store.listRunsBetween(t, orgId, tasks.map((x) => x.id), q.from, q.to, 
+        // one row past the caps tells the assembly where to cut
+        calendarRunReadLimit(limits));
+        const settings = await readScheduleSettings(t, this.config, orgId);
+        return assembleCalendar({
+            tasks,
+            runs,
+            viewerAccountId: actor.accountId,
+            from: q.from,
+            to: q.to,
+            timeZone: q.timeZone,
+            now,
+            plan: settings.enabled,
+            catchUpWindowMinutes: settings.catchUpWindowMinutes,
+            collapse: q.taskId === undefined,
+        }, limits);
+    }
     /**
      * The tasks of `tasks` that post into the conversation: a `conversation` task naming it, or a
      * `chat` task whose chat the conversation is a thread of (spec §10 side panel).
@@ -472,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,
@@ -736,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,
@@ -767,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).
      */
@@ -797,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`. */
@@ -1030,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);
@@ -1115,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.controller.d.ts

@@ -1,8 +1,9 @@
 import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
+import type { CalendarAnswer } from "./calendar.js";
 import { type ChatTarget, type GrantableTool, type ScheduledTaskGrantView, type ScheduledTaskListItem, ScheduledTasksService } from "./scheduled-tasks.service.js";
-import { type ScheduleChatTargetsQuery, type ScheduleCreateBody, type ScheduleGrantableQuery, type ScheduleGrantParams, type ScheduleGrantsBody, type ScheduleListQuery, type ScheduleParams, type ScheduleRunBody, type ScheduleRunsQuery, type ScheduleUpdateBody } from "./schedules.schemas.js";
+import { type ScheduleCalendarQuery, type ScheduleChatTargetsQuery, type ScheduleCreateBody, type ScheduleGrantableQuery, type ScheduleGrantParams, type ScheduleGrantsBody, type ScheduleListQuery, type ScheduleParams, type ScheduleRunBody, type ScheduleRunsQuery, type ScheduleUpdateBody } from "./schedules.schemas.js";
 import type { ScheduledTask, ScheduledTaskGrant, TaskRun } from "./types.js";
 /**
  * Scheduled tasks (`/api/v1/orgs/:orgId/schedules`, spec 2026-11-11-scheduled-tasks §10); human
@@ -10,6 +11,8 @@ import type { ScheduledTask, ScheduledTaskGrant, TaskRun } from "./types.js";
  * - `GET /` → `{ items }`: the caller's own tasks, each with its `lastRun`; `?all=true` every task
  *   of the org (org admins, `schedules.manage`, enforced by the service: 403 `forbidden`
  *   otherwise); `?conversationId=` only those posting into that conversation;
+ * - `GET /calendar?from&to&timeZone[&all][&taskId]` → the calendar (runs, planned occurrences,
+ *   collapsed task-days; calendar spec §5.1), `org.read` like the list, `all` as the list's;
  * - `GET /chat-targets` → `{ items }`: the chats the caller can point a `chat` task at;
  * - `GET /grantable-tools?agentId=` → `{ items }`: the agent's tools, each grantable or why not;
  * - `POST /` → 201 `{ task }` (`timeZone` is the browser zone, a fallback only);
@@ -30,6 +33,7 @@ export declare class SchedulesController {
     list(principal: Principal, org: OrgContext, q: z.infer<typeof ScheduleListQuery>): Promise<{
         items: ScheduledTaskListItem[];
     }>;
+    calendar(principal: Principal, org: OrgContext, q: z.infer<typeof ScheduleCalendarQuery>): Promise<CalendarAnswer>;
     chatTargets(principal: Principal, org: OrgContext, _q: z.infer<typeof ScheduleChatTargetsQuery>): Promise<{
         items: ChatTarget[];
     }>;

package/dist/schedules/schedules.controller.js

@@ -12,13 +12,15 @@ import { CurrentPrincipal, requireUser } from "../identity/principal.js";
 import { ZBody, ZParam, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { ScheduledTasksService, } from "./scheduled-tasks.service.js";
-import { createInputOf, grantsOf, ScheduleChatTargetsQueryDto, ScheduleCreateBodyDto, ScheduleGrantableQueryDto, ScheduleGrantParamsDto, ScheduleGrantsBodyDto, ScheduleListQueryDto, ScheduleParamsDto, ScheduleRunBodyDto, ScheduleRunsQueryDto, ScheduleUpdateBodyDto, updateInputOf, } from "./schedules.schemas.js";
+import { calendarInputOf, createInputOf, grantsOf, ScheduleCalendarQueryDto, ScheduleChatTargetsQueryDto, ScheduleCreateBodyDto, ScheduleGrantableQueryDto, ScheduleGrantParamsDto, ScheduleGrantsBodyDto, ScheduleListQueryDto, ScheduleParamsDto, ScheduleRunBodyDto, ScheduleRunsQueryDto, ScheduleUpdateBodyDto, updateInputOf, } from "./schedules.schemas.js";
 /**
  * Scheduled tasks (`/api/v1/orgs/:orgId/schedules`, spec 2026-11-11-scheduled-tasks §10); human
  * users only (a service token gets 403).
  * - `GET /` → `{ items }`: the caller's own tasks, each with its `lastRun`; `?all=true` every task
  *   of the org (org admins, `schedules.manage`, enforced by the service: 403 `forbidden`
  *   otherwise); `?conversationId=` only those posting into that conversation;
+ * - `GET /calendar?from&to&timeZone[&all][&taskId]` → the calendar (runs, planned occurrences,
+ *   collapsed task-days; calendar spec §5.1), `org.read` like the list, `all` as the list's;
  * - `GET /chat-targets` → `{ items }`: the chats the caller can point a `chat` task at;
  * - `GET /grantable-tools?agentId=` → `{ items }`: the agent's tools, each grantable or why not;
  * - `POST /` → 201 `{ task }` (`timeZone` is the browser zone, a fallback only);
@@ -48,6 +50,11 @@ let SchedulesController = class SchedulesController {
         });
         return { items };
     }
+    // declared before `:id`; org.read like the list (a creator demoted to guest still reads their own)
+    async calendar(principal, org, q) {
+        const p = requireUser(principal);
+        return this.tasks.calendar(org.orgId, { accountId: p.account.id }, calendarInputOf(q));
+    }
     async chatTargets(principal, org, _q) {
         const p = requireUser(principal);
         return { items: await this.tasks.chatTargets(org.orgId, p.account.id) };
@@ -134,6 +141,13 @@ __decorate([
     __param(1, CurrentOrg()),
     __param(2, ZQuery(ScheduleListQueryDto))
 ], SchedulesController.prototype, "list", null);
+__decorate([
+    Get("calendar"),
+    OrgAction("org.read"),
+    __param(0, CurrentPrincipal()),
+    __param(1, CurrentOrg()),
+    __param(2, ZQuery(ScheduleCalendarQueryDto))
+], SchedulesController.prototype, "calendar", null);
 __decorate([
     Get("chat-targets"),
     OrgAction("schedules.use"),

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/schedules/schedules.schemas.d.ts

@@ -138,6 +138,21 @@ export declare const ScheduleListQuery: z.ZodObject<{
     }>>;
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+/**
+ * The calendar's range (`from < to`, at most 43 days, 2 with `taskId`: checked by the service),
+ * the viewer's zone (local days for the collapse and the cut), `all` (org admins) and `taskId`
+ * (one task, never collapsed).
+ */
+export declare const ScheduleCalendarQuery: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    timeZone: z.ZodString;
+    all: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
+    taskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const ScheduleChatTargetsQuery: z.ZodObject<{}, z.core.$strict>;
 export declare const ScheduleGrantableQuery: z.ZodObject<{
     agentId: z.ZodString;
@@ -258,6 +273,18 @@ declare const ScheduleListQueryDto_base: import("../infra/validation/create-zod-
 }, z.core.$strict>>;
 export declare class ScheduleListQueryDto extends ScheduleListQueryDto_base {
 }
+declare const ScheduleCalendarQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    timeZone: z.ZodString;
+    all: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
+    taskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare class ScheduleCalendarQueryDto extends ScheduleCalendarQueryDto_base {
+}
 declare const ScheduleChatTargetsQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{}, z.core.$strict>>;
 export declare class ScheduleChatTargetsQueryDto extends ScheduleChatTargetsQueryDto_base {
 }
@@ -313,4 +340,12 @@ export declare function createInputOf(body: z.infer<typeof ScheduleCreateBody>):
 };
 /** A patch body as the service's input (an explicit `timeZone` changes the task's zone). */
 export declare function updateInputOf(body: z.infer<typeof ScheduleUpdateBody>): UpdateTaskInput;
+/** A calendar query as the service's input. */
+export declare const calendarInputOf: (q: z.infer<typeof ScheduleCalendarQuery>) => {
+    from: Date;
+    to: Date;
+    timeZone: string;
+    all: boolean;
+    taskId?: string;
+};
 export {};

package/dist/schedules/schedules.schemas.js

@@ -86,6 +86,22 @@ export const ScheduleListQuery = z
     conversationId: Id.optional(),
 })
     .strict();
+/** An instant with an offset (`2026-11-09T00:00:00+08:00`). */
+const Instant = z.string().datetime({ offset: true });
+/**
+ * The calendar's range (`from < to`, at most 43 days, 2 with `taskId`: checked by the service),
+ * the viewer's zone (local days for the collapse and the cut), `all` (org admins) and `taskId`
+ * (one task, never collapsed).
+ */
+export const ScheduleCalendarQuery = z
+    .object({
+    from: Instant,
+    to: Instant,
+    timeZone: IanaTimeZone,
+    all: z.enum(["true", "false"]).optional(),
+    taskId: Id.optional(),
+})
+    .strict();
 export const ScheduleChatTargetsQuery = z.object({}).strict();
 export const ScheduleGrantableQuery = z.object({ agentId: Id }).strict();
 export const ScheduleParams = z.object({ id: Id });
@@ -103,6 +119,8 @@ export class ScheduleUpdateBodyDto extends createZodDto(ScheduleUpdateBody, "Sch
 }
 export class ScheduleListQueryDto extends createZodDto(ScheduleListQuery, "ScheduleListQuery") {
 }
+export class ScheduleCalendarQueryDto extends createZodDto(ScheduleCalendarQuery, "ScheduleCalendarQuery") {
+}
 export class ScheduleChatTargetsQueryDto extends createZodDto(ScheduleChatTargetsQuery, "ScheduleChatTargetsQuery") {
 }
 export class ScheduleGrantableQueryDto extends createZodDto(ScheduleGrantableQuery, "ScheduleGrantableQuery") {
@@ -120,6 +138,7 @@ export class ScheduleGrantParamsDto extends createZodDto(ScheduleGrantParams, "S
 /** The schedule routes the Platform operations mirror (`check:platform-ops` keys). */
 export const SCHEDULE_ROUTES = [
     { route: "GET /api/v1/orgs/:orgId/schedules", query: ScheduleListQuery },
+    { route: "GET /api/v1/orgs/:orgId/schedules/calendar", query: ScheduleCalendarQuery },
     { route: "GET /api/v1/orgs/:orgId/schedules/chat-targets", query: ScheduleChatTargetsQuery },
     { route: "GET /api/v1/orgs/:orgId/schedules/grantable-tools", query: ScheduleGrantableQuery },
     { route: "POST /api/v1/orgs/:orgId/schedules", body: ScheduleCreateBody },
@@ -184,3 +203,11 @@ export function updateInputOf(body) {
         ...(expiresAt !== undefined && { expiresAt: expiresAt === null ? null : new Date(expiresAt) }),
     };
 }
+/** A calendar query as the service's input. */
+export const calendarInputOf = (q) => ({
+    from: new Date(q.from),
+    to: new Date(q.to),
+    timeZone: q.timeZone,
+    all: q.all === "true",
+    ...(q.taskId !== undefined && { taskId: q.taskId }),
+});

package/dist/schedules/store.d.ts

@@ -68,6 +68,11 @@ export declare class ScheduledTaskStore {
     countFiredSince(t: KernelSchemaDb, orgId: string, since: Date): Promise<number>;
     /** A task's runs, latest tick first. */
     listRuns(t: KernelSchemaDb, taskId: string, limit: number): Promise<TaskRun[]>;
+    /**
+     * The runs of these tasks of the org with `scheduled_for` in `[from, to)`, trial included, by tick, at most
+     * `limit` (the calendar; `scheduled_task_runs_task_idx` per task).
+     */
+    listRunsBetween(t: KernelSchemaDb, orgId: string, taskIds: readonly string[], from: Date, to: Date, limit: number): Promise<TaskRun[]>;
     listGrants(t: KernelSchemaDb, taskId: string): Promise<ScheduledTaskGrant[]>;
     /** Adds a grant, replacing the task's grant of the same tool key. */
     addGrant(t: KernelSchemaDb, taskId: string, grant: ScheduledTaskGrant): Promise<void>;

package/dist/schedules/store.js

@@ -329,6 +329,26 @@ let ScheduledTaskStore = class ScheduledTaskStore {
             .execute();
         return rows.map(toRun);
     }
+    /**
+     * The runs of these tasks of the org with `scheduled_for` in `[from, to)`, trial included, by tick, at most
+     * `limit` (the calendar; `scheduled_task_runs_task_idx` per task).
+     */
+    async listRunsBetween(t, orgId, taskIds, from, to, limit) {
+        if (taskIds.length === 0)
+            return [];
+        const rows = await t
+            .selectFrom("scheduled_task_runs")
+            .selectAll()
+            .where("org_id", "=", orgId)
+            .where("task_id", "in", [...taskIds])
+            .where("scheduled_for", ">=", from)
+            .where("scheduled_for", "<", to)
+            .orderBy("scheduled_for")
+            .orderBy("id")
+            .limit(limit)
+            .execute();
+        return rows.map(toRun);
+    }
     async listGrants(t, taskId) {
         const rows = await t
             .selectFrom("scheduled_task_grants")

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);

package/dist/tools/approvals.service.d.ts

@@ -8,6 +8,7 @@ import { KernelEvents } from "../infra/events/kernel-events.js";
 import { LockService } from "../infra/lock/lock.service.js";
 import { DevicePolicyService } from "../local-devices/device-policy.service.js";
 import { type OrgRole } from "../orgs/roles.js";
+import { RunResume } from "../runtime/run-jobs.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { ScheduledTaskStore } from "../schedules/store.js";
 import type { ApprovalPolicySource } from "./pipeline.js";
@@ -206,10 +207,12 @@ export interface ToolGrantView {
  * 工具调用审批：新建（loop 调用）、列出 / 查看 / 处理（HTTP），以及「以后都允许」授权的查看与撤销。
  * 状态全部在 PG：处理决定在事务里 `SELECT … FOR UPDATE` 审批行，多副本并发处理同一审批时恰好一个生效。
  *
- * A decision is announced after the commit as the domain event `approval.decided` (exactly once:
- * only the decision that changed the row from pending), which the run's waits follow to resume it
- * (spec §3b; the wait sweep resumes a run whose resume was lost). Events are appended in the
- * context's transaction (`EventLog.appendIn`) and published after the commit.
+ * A decision resumes its waiting run in the decision's transaction (`RunResume.resumeIn`, after the
+ * decided row: lock order approval, then run; transactional outbox spec §6). It is announced after
+ * the commit as the domain event `approval.decided` (exactly once: only the decision that changed
+ * the row from pending; no kernel subscriber: the IM card update is owed by the `approval_decided`
+ * append, transactional outbox spec §8.1). Events are appended in the context's transaction
+ * (`EventLog.appendIn`) and published after the commit.
  */
 export declare class ApprovalsService {
     private readonly db;
@@ -226,6 +229,8 @@ export declare class ApprovalsService {
     readonly lockService: LockService;
     /** A trial run's 「这次允许」 becomes a task grant only within the org's egress. */
     private readonly sandbox;
+    /** A decision resumes its waiting run in the decision's transaction. */
+    private readonly resumes;
     constructor(db: KernelDb, config: Pick<KernelConfigService, "get">, eventLog: Pick<EventLog, "appendIn" | "notify">, events: Pick<KernelEvents, "emit">, txHost: TransactionHost, schedules: Pick<ScheduledTaskStore, "addGrant">, 
     /** A trial approval is kept only for a tool the task may hold as a grant (its agent's tools). */
     registry: Pick<ToolRegistry, "forAgent">, 
@@ -234,7 +239,9 @@ export declare class ApprovalsService {
     /** One decision of a network ask at a time, across replicas (the op is sent before the transaction). */
     lockService: LockService, 
     /** A trial run's 「这次允许」 becomes a task grant only within the org's egress. */
-    sandbox: Pick<SandboxService, "ceilingLimits">);
+    sandbox: Pick<SandboxService, "ceilingLimits">, 
+    /** A decision resumes its waiting run in the decision's transaction. */
+    resumes: Pick<RunResume, "resumeIn">);
     /**
      * 新建 pending 审批（`expires_at` = 现在 + `tools.approvalTimeoutHours`）并写 `approval_requested`，同一事务。
      * 按 (run_id, call_id, attempt) 幂等：已存在则返回已有记录（不覆盖），事件按 `approval_requested:<approvalId>` 幂等。
@@ -331,11 +338,22 @@ export declare class ApprovalsService {
      */
     cancelPendingIn(runId: string): Promise<ApprovalRecord[]>;
     /**
-     * 在调用方的事务内（`mandatory`）取消某组织里指定由 `accountId` 处理（`requested_for`）的全部 pending 审批（成员离职），
-     * 走与 {@link cancelPendingIn} 相同的取消路径：置 cancelled、写 `approval_decided{cancelled}`（处理人为 null）。
-     * 返回被取消的记录与各会话写到的最大 seq；调用方提交后发布事件（并可续跑对应运行）。
+     * The conversations of `orgId` holding a pending approval `accountId` is asked to decide
+     * (`requested_for`), read without locks: offboarding locks them, by tree root first
+     * (`lockConversationTrees`), before {@link cancelPendingFor}.
      */
-    cancelPendingFor(orgId: string, accountId: string): Promise<{
+    pendingConversationsFor(orgId: string, accountId: string): Promise<string[]>;
+    /**
+     * In the caller's transaction (`mandatory`; offboarding): cancels every pending approval of
+     * `orgId` that `accountId` is asked to decide (`requested_for`) in `conversationIds`, the
+     * conversations the caller already locked (by tree root first, `lockConversationTrees`; lock
+     * order: conversations, then approval rows), along the same path as {@link cancelPendingIn}:
+     * `cancelled`, `approval_decided{cancelled}` with no decider. An approval asked meanwhile in
+     * another conversation is left to its run's stop, so no conversation is locked after a row.
+     * Returns the cancelled records and the highest seq written per conversation; the caller
+     * publishes after the commit.
+     */
+    cancelPendingFor(orgId: string, accountId: string, conversationIds: readonly string[]): Promise<{
         records: ApprovalRecord[];
         seqs: Map<string, number>;
     }>;
@@ -346,13 +364,25 @@ export declare class ApprovalsService {
      * active runs `authorAccountId` started, in the conversation and in its sub-agents'
      * conversations at any depth (their asks are shown in the root). Each becomes `skipped` with
      * `approval_decided{skipped}` by the author; access stays blocked. Returns the skipped records and
-     * the highest seq written per conversation; the caller notifies and emits
-     * `approval.decided{skipped}` after the commit, so the runs resume.
+     * the highest seq written per conversation; the caller resumes their waiting runs in this
+     * transaction once every skipped row is locked (`ConversationsService.skipWaitsIn`), and notifies
+     * and emits the domain event `approval.decided{skipped}` after the commit (its IM card update is
+     * owed by the append, transactional outbox spec §8.1).
      */
     skipNetworkIn(conversationId: string, authorAccountId: string): Promise<{
         records: ApprovalRecord[];
         seqs: Map<string, number>;
     }>;
+    /**
+     * Locks the conversation row of approval `id` (`SELECT … FOR UPDATE`; re-entrant with the lock
+     * `EventLog.appendIn` takes later). Every write to an approval row takes its conversation's lock
+     * first, then the approval row, then the run row, as the stop of a waiting run
+     * (`Waits.abortWaitingIn`) and the questions do, so no two of them can deadlock. False: no such
+     * approval (in `orgId`).
+     */
+    private lockConversationOf;
+    /** Locks, in id order, the conversations `ids` selects; returns their ids. */
+    private lockConversations;
     /** `conversationId` and its sub-agents' conversations at any depth (at most 16 levels). */
     private subtreeOf;
     /**