agor-live 0.22.0 → 0.23.2

package/dist/daemon/services/repos.js

@@ -191,29 +191,35 @@ import path2 from "path";
 import {
   ensureBranchStorageModeAllowed,
   extractSlugFromUrl,
-  isBranchRbacEnabled,
   isValidGitUrl,
   isValidSlug,
   normalizeRepoUrl,
   PAGINATION,
   parseAgorYml,
-  resolveBranchStorageConfig
+  resolveBranchStorageConfig,
+  resolveExecutionSecurityMode
 } from "@agor/core/config";
-import { BranchRepository, RepoRepository, shortId as shortId2 } from "@agor/core/db";
+import {
+  BranchRepository,
+  RepoRepository,
+  shortId as shortId2
+} from "@agor/core/db";
 import { autoAssignBranchUniqueId } from "@agor/core/environment/variable-resolver";
 import { BadRequest, Forbidden, NotAuthenticated } from "@agor/core/feathers";
 import {
   assertRemoteRefVisibleForClone,
-  getBranchPath,
   getDefaultBranch,
   getRemoteUrl,
-  getReposDir,
   isValidGitRepo,
-  redactGitUrlCredentials,
   scanGitConfigRemoteCredentials,
-  scrubGitConfigRemoteCredentials,
+  scrubGitConfigRemoteCredentials
+} from "@agor/core/git/exec";
+import {
+  getBranchPath,
+  getReposDir,
+  redactGitUrlCredentials,
   stripGitUrlCredentials
-} from "@agor/core/git";
+} from "@agor/core/git/pure";
 
 // src/adapters/drizzle.ts
 import { NotFoundError } from "@agor/core/utils/errors";
@@ -232,6 +238,34 @@ var DrizzleService = class {
   // Event emitter for FeathersJS (will be injected by framework)
   // biome-ignore lint/suspicious/noExplicitAny: FeathersJS event system
   emit;
+  /** Extract resolved tenant context from Feathers params. */
+  getTenant(params) {
+    return params?.tenant;
+  }
+  /**
+   * Whether a row belongs to the current tenant. Rows from pre-migration test
+   * fixtures that do not expose tenant_id are treated as visible so existing
+   * single-tenant unit tests keep working; migrated DB rows always carry it.
+   */
+  rowBelongsToTenant(row, tenant) {
+    if (!tenant) return true;
+    const record = row;
+    if (!("tenant_id" in record)) return true;
+    return record.tenant_id === tenant.tenant_id;
+  }
+  /** Stamp tenant_id onto created rows and prevent client-supplied drift. */
+  withTenant(data, params) {
+    const tenant = this.getTenant(params);
+    if (!tenant || !data || typeof data !== "object" || Array.isArray(data)) return data;
+    return { ...data, tenant_id: tenant.tenant_id };
+  }
+  /** Never allow a patch/update to move a row across tenants. */
+  stripTenantMutation(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) return data;
+    const clone = { ...data };
+    delete clone.tenant_id;
+    return clone;
+  }
   /**
    * Extract query parameters from params
    */
@@ -323,12 +357,28 @@ var DrizzleService = class {
       data: paginated
     };
   }
+  /**
+   * Resolve the candidate row set that `find` filters, sorts, and paginates.
+   *
+   * The base implementation reads the whole table and relies on `filterData` to
+   * narrow it in memory. Subclasses may override this to push high-selectivity
+   * predicates into SQL; because `find` always re-applies every query filter via
+   * `filterData`, an override only needs to return a superset of the matching
+   * rows for the result to stay identical.
+   */
+  async fetchData(_query, _params) {
+    return this.repository.findAll();
+  }
   /**
    * Find records
    */
   async find(params) {
     const query = this.getQuery(params);
-    let data = await this.repository.findAll();
+    let data = await this.fetchData(query, params);
+    const tenant = this.getTenant(params);
+    if (tenant) {
+      data = data.filter((row) => this.rowBelongsToTenant(row, tenant));
+    }
     data = this.filterData(data, query);
     const total = data.length;
     data = this.sortData(data, query.$sort);
@@ -340,10 +390,13 @@ var DrizzleService = class {
    */
   async get(id, _params) {
     const prefetched = _params?._agorPrefetchedRecord;
-    if (prefetched && prefetched.idField === this.id && prefetched.id === String(id) && String(prefetched.record[this.id]) === String(id)) {
+    if (prefetched && prefetched.idField === this.id && prefetched.id === String(id) && String(prefetched.record[this.id]) === String(id) && this.rowBelongsToTenant(prefetched.record, this.getTenant(_params))) {
       return prefetched.record;
     }
     const result = await this.repository.findById(String(id));
+    if (result && !this.rowBelongsToTenant(result, this.getTenant(_params))) {
+      throw new NotFoundError(this.resourceType, String(id));
+    }
     if (!result) {
       throw new NotFoundError(this.resourceType, String(id));
     }
@@ -355,14 +408,18 @@ var DrizzleService = class {
   async create(data, params) {
     if (Array.isArray(data)) {
       const results = await Promise.all(
-        data.map((item) => this.repository.create(item))
+        data.map(
+          (item) => this.repository.create(this.withTenant(item, params))
+        )
       );
       for (const result2 of results) {
         this.emit?.("created", result2, params);
       }
       return results;
     }
-    const result = await this.repository.create(data);
+    const result = await this.repository.create(
+      this.withTenant(data, params)
+    );
     this.emit?.("created", result, params);
     return result;
   }
@@ -378,7 +435,10 @@ var DrizzleService = class {
    */
   async update(id, data, params) {
     await this.get(id, params);
-    const result = await this.repository.update(String(id), data);
+    const result = await this.repository.update(
+      String(id),
+      this.stripTenantMutation(data)
+    );
     this.emit?.("updated", result, params);
     return result;
   }
@@ -392,12 +452,14 @@ var DrizzleService = class {
       }
       const query = this.getQuery(params);
       let records = await this.repository.findAll();
+      const tenant = this.getTenant(params);
+      if (tenant) records = records.filter((row) => this.rowBelongsToTenant(row, tenant));
       records = this.filterData(records, query);
       const results = await Promise.all(
         records.map(
           (record) => this.repository.update(
             record[this.id],
-            data
+            this.stripTenantMutation(data)
           )
         )
       );
@@ -407,7 +469,10 @@ var DrizzleService = class {
       return results;
     }
     await this.get(id, params);
-    const result = await this.repository.update(String(id), data);
+    const result = await this.repository.update(
+      String(id),
+      this.stripTenantMutation(data)
+    );
     this.emit?.("patched", result, params);
     return result;
   }
@@ -421,6 +486,8 @@ var DrizzleService = class {
       }
       const query = this.getQuery(params);
       let records = await this.repository.findAll();
+      const tenant = this.getTenant(params);
+      if (tenant) records = records.filter((row) => this.rowBelongsToTenant(row, tenant));
       records = this.filterData(records, query);
       await Promise.all(records.map((record) => this.repository.delete(record[this.id])));
       for (const record of records) {
@@ -587,6 +654,13 @@ function generateTaskId() {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function findExecutorPath() {
+  const configuredPath = process.env.AGOR_EXECUTOR_PATH;
+  if (configuredPath) {
+    if (!existsSync(configuredPath)) {
+      throw new Error(`Configured AGOR_EXECUTOR_PATH does not exist: ${configuredPath}`);
+    }
+    return configuredPath;
+  }
   const dirname = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
   const possiblePaths = [
     path.join(dirname, "../executor/cli.js"),
@@ -697,6 +771,12 @@ function spawnExecutorLocal(payload, options) {
     options.onExit?.(127);
     return;
   }
+  let reportedExit = false;
+  const reportExit = (code) => {
+    if (reportedExit) return;
+    reportedExit = true;
+    options.onExit?.(code);
+  };
   const executorProcess = spawn(cmd, args, {
     cwd,
     env: asUser ? void 0 : { ...envWithDaemonUrl },
@@ -710,6 +790,7 @@ function spawnExecutorLocal(payload, options) {
   onSpawn?.(executorProcess);
   executorProcess.on("error", (error) => {
     console.error(`${logPrefix} Spawn error:`, error.message);
+    reportExit(127);
   });
   executorProcess.on("exit", (code) => {
     if (code === 0) {
@@ -717,7 +798,7 @@ function spawnExecutorLocal(payload, options) {
     } else {
       console.error(`${logPrefix} Executor exited with code ${code}`);
     }
-    options.onExit?.(code);
+    reportExit(code);
   });
   executorProcess.stdin?.write(JSON.stringify(payload));
   executorProcess.stdin?.end();
@@ -730,6 +811,12 @@ function spawnExecutorWithTemplate(payload, options) {
   console.log(`${logPrefix} Task ID: ${templateVariables.task_id}`);
   console.log(`${logPrefix} Command: ${payload.command}`);
   console.log(`${logPrefix} Template command (first 200 chars): ${command.slice(0, 200)}...`);
+  let reportedExit = false;
+  const reportExit = (code) => {
+    if (reportedExit) return;
+    reportedExit = true;
+    options.onExit?.(code);
+  };
   const executorProcess = spawn("sh", ["-c", command], {
     env: { ...process.env, LOG_LEVEL: logLevel },
     stdio: ["pipe", "pipe", "pipe"]
@@ -743,6 +830,7 @@ function spawnExecutorWithTemplate(payload, options) {
   });
   executorProcess.on("error", (error) => {
     console.error(`${logPrefix} Spawn error:`, error.message);
+    reportExit(127);
   });
   executorProcess.on("exit", (code) => {
     if (code === 0) {
@@ -754,7 +842,7 @@ function spawnExecutorWithTemplate(payload, options) {
         `${logPrefix} Executor exited with code ${code} (task: ${templateVariables.task_id})`
       );
     }
-    options.onExit?.(code);
+    reportExit(code);
   });
   executorProcess.stdin?.write(JSON.stringify(payload));
   executorProcess.stdin?.end();
@@ -1034,12 +1122,19 @@ function createServiceToken(jwtSecret, expiresIn, scope = {}) {
     expiresIn || "5m"
   );
 }
-function generateSessionToken(app) {
+function serviceTokenScopeForParams(params) {
+  const tenantId = params?.tenant?.tenant_id ?? params?.tenant_id ?? params?.user?.tenant_id;
+  return tenantId ? { tenant_id: tenantId } : {};
+}
+function generateSessionToken(app, scope = {}) {
   const jwtSecret = app.settings.authentication?.secret;
   if (!jwtSecret) {
     throw new Error("JWT secret not configured in app settings");
   }
-  return createServiceToken(jwtSecret);
+  return createServiceToken(jwtSecret, void 0, scope);
+}
+function generateScopedServiceToken(app, params) {
+  return generateSessionToken(app, serviceTokenScopeForParams(params));
 }
 var spawnExecutorFireAndForget = spawnExecutor;
 
@@ -1143,10 +1238,11 @@ var ReposService = class extends DrizzleService {
       }
     }
     const userId = params?.user?.user_id;
-    const sessionToken = generateSessionToken(
-      this.app
+    const sessionToken = generateScopedServiceToken(
+      this.app,
+      params
     );
-    const rbacEnabled = isBranchRbacEnabled();
+    const initUnixGroup = resolveExecutionSecurityMode().shouldInitUnixGroups;
     const asUser = await resolveGitImpersonationForUser(this.db, userId);
     const expectedLocalPath = path2.join(getReposDir(), slug);
     const placeholder = await this.create(
@@ -1180,7 +1276,7 @@ var ReposService = class extends DrizzleService {
           ...data.default_branch ? { default_branch: data.default_branch } : {},
           createDbRecord: true,
           userId,
-          initUnixGroup: rbacEnabled
+          initUnixGroup
         }
       },
       {
@@ -1569,10 +1665,11 @@ Use a different slug with: --slug custom/name`
       );
     }
     try {
-      const sessionToken = generateSessionToken(
-        this.app
+      const sessionToken = generateScopedServiceToken(
+        this.app,
+        params
       );
-      const rbacEnabled = isBranchRbacEnabled();
+      const initUnixGroup = resolveExecutionSecurityMode().shouldInitUnixGroups;
       const asUser = await resolveGitImpersonationForUser(this.db, userId);
       const safeRemoteUrl = repo.remote_url ? stripGitUrlCredentials(repo.remote_url) : void 0;
       spawnExecutorFireAndForget(
@@ -1591,8 +1688,8 @@ Use a different slug with: --slug custom/name`
             createBranch: data.createBranch,
             refType: data.refType,
             userId,
-            // Unix group isolation (only when RBAC is enabled)
-            initUnixGroup: rbacEnabled,
+            // Unix group isolation (only when unix_user_mode is non-simple)
+            initUnixGroup,
             othersAccess: branch.others_fs_access || "read",
             // Branch storage mode (forwarded for the clone-mode code path)
             storageMode,
@@ -1636,8 +1733,9 @@ Use a different slug with: --slug custom/name`
     return branch;
   }
   async runAgorYmlExecutorCommand(repo, branch, command, params, serviceParams) {
-    const sessionToken = generateSessionToken(
-      this.app
+    const sessionToken = generateScopedServiceToken(
+      this.app,
+      serviceParams
     );
     const asUser = await resolveExecutorReadAsUser(
       this.db,
@@ -1760,8 +1858,9 @@ Use a different slug with: --slug custom/name`
       `\u{1F5D1}\uFE0F  Repo deletion: Found ${branches.length} branch(s) for repo ${repo.slug} (${repo.repo_id})`
     );
     if (cleanup && repo.repo_type === "remote") {
-      const sessionToken = generateSessionToken(
-        this.app
+      const sessionToken = generateScopedServiceToken(
+        this.app,
+        params
       );
       const cleanupResult = await runExecutorCommand(
         {

package/dist/daemon/services/scheduler.d.ts

@@ -18,16 +18,12 @@
  * **Per-schedule advisory lock (Postgres only):** each due schedule's
  * spawn runs inside its own transaction with
  * `pg_try_advisory_xact_lock(hash(schedule_id))`. This serves
- * same-schedule dedup if multi-daemon is ever wired up — but Agor
- * **is single-daemon only today**, and the per-schedule lock does NOT
- * by itself preserve the branch-wide `allow_concurrent_runs=false`
- * invariant across daemons (two daemons could lock two different
- * schedules on the same branch and both pass the branch concurrency
- * check). Branch-scoped advisory locking is deferred until multi-
- * daemon is actually supported; the partial unique index
- * `sessions_schedule_run_unique` provides DB-level dedup either way.
- * SQLite is single-node by definition; the lock helper is a no-op
- * there.
+ * same-schedule dedup if multi-daemon is ever wired up. Because the
+ * concurrency guard is intentionally per-schedule, different schedules
+ * on the same branch may run at the same time; the partial unique index
+ * `sessions_schedule_run_unique` provides DB-level dedup for a single
+ * schedule fire either way. SQLite is single-node by definition; the
+ * lock helper is a no-op there.
  *
  * **Smart Recovery:**
  * - If scheduler is down for an extended period, only schedules LATEST
@@ -45,8 +41,8 @@
  *   context. Branch fields are also exposed under `{{ worktree.* }}`
  *   as a v0.19 backwards-compat alias.
  */
-import type { Database } from '@agor/core/db';
-import type { Branch, Schedule, ScheduleID, Session, UUID } from '@agor/core/types';
+import type { TenantScopeAwareDatabase } from '@agor/core/db';
+import type { Branch, Schedule, ScheduleID, Session, TenantID, UUID } from '@agor/core/types';
 import type { UnixUserMode } from '@agor/core/unix';
 import type { Application } from '../declarations';
 /**
@@ -63,13 +59,13 @@ import type { Application } from '../declarations';
  */
 export declare function renderSchedulePrompt(template: string, branch: Branch, schedule: Schedule, scheduledRunAt: number): string;
 /**
- * Error thrown when execute-now is blocked because a session is already running
- * in the branch and allow_concurrent_runs is not enabled. Routes can catch
+ * Error thrown when execute-now is blocked because an active run from the same
+ * schedule exists and allow_concurrent_runs is not enabled. Routes can catch
  * this and surface it as a 409 Conflict.
  */
 export declare class ScheduleBusyError extends Error {
     readonly code = "schedule_busy";
-    constructor(branchName: string);
+    constructor(scheduleName: string);
 }
 /**
  * Error thrown when execute-now is called on a schedule that is not
@@ -88,6 +84,8 @@ export interface SchedulerConfig {
     debug?: boolean;
     /** Unix user mode for validation (default: 'simple') */
     unixUserMode?: UnixUserMode;
+    /** Static/single-tenant id used for request-less cron ticks. Undefined means discover due schedule tenants from schedule rows. */
+    tenantId?: TenantID | string;
 }
 export declare class SchedulerService {
     private app;
@@ -100,7 +98,7 @@ export declare class SchedulerService {
     private sessionRepo;
     private userRepo;
     private sessionMCPRepo;
-    constructor(db: Database, app: Application, config?: SchedulerConfig);
+    constructor(db: TenantScopeAwareDatabase, app: Application, config?: SchedulerConfig);
     /**
      * Start the scheduler tick loop
      */
@@ -120,6 +118,7 @@ export declare class SchedulerService {
      * 3. Process the schedule (dedup, concurrency check, spawn).
      */
     private tick;
+    private findDueScheduleRefs;
     /**
      * Process a single schedule.
      *
@@ -147,7 +146,7 @@ export declare class SchedulerService {
      * @throws ScheduleNotReadyError when the schedule is disabled or its
      *   branch can't be loaded.
      * @throws ScheduleBusyError when allow_concurrent_runs is false and
-     *   the branch already has an active session.
+     *   this schedule already has an active run.
      */
     executeScheduleNow(opts: {
         scheduleId: ScheduleID;
@@ -183,9 +182,9 @@ export declare class SchedulerService {
      * 1. Look up the schedule's branch (cascaded delete means it should
      *    always exist; we still handle null defensively).
      * 2. Dedup against `sessions(schedule_id, scheduled_run_at)`.
-     * 3. Enforce `allow_concurrent_runs` against any active session in the
-     *    SAME BRANCH (sibling schedules on the same branch are sequential
-     *    by default; opt out per-schedule via allow_concurrent_runs).
+     * 3. Enforce `allow_concurrent_runs` against any active session spawned
+     *    by the SAME SCHEDULE. Different schedules on the same branch do not
+     *    block one another.
      * 4. Render prompt template (Handlebars).
      * 5. Look up creator's unix_username for execution context.
      * 6. Create session with schedule metadata + `schedule_id` FK.
@@ -198,13 +197,10 @@ export declare class SchedulerService {
      * 9. Enforce retention policy (oldest sessions on this schedule_id
      *    are deleted).
      *
-     * NOTE (multi-daemon, deferred): with the current per-schedule
-     * advisory lock, two daemons can each lock different schedules on
-     * the same branch and both pass the branch-wide concurrency guard
-     * before either creates a session, then both spawn. Branch-scoped
-     * coordination (lock on branch when allow_concurrent_runs=false)
-     * will be needed once we support multi-daemon. Out of scope for V1
-     * since multi-daemon isn't supported yet.
+     * NOTE (multi-daemon, deferred): the per-schedule advisory lock and
+     * partial unique index guard same-schedule races. They deliberately do
+     * not serialize sibling schedules on the same branch, matching the
+     * schedule-scoped meaning of `allow_concurrent_runs=false`.
      */
     private spawnScheduledSession;
     /**

package/dist/daemon/services/scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAe9C,OAAO,KAAK,EACV,MAAM,EAGN,QAAQ,EACR,UAAU,EACV,OAAO,EAGP,IAAI,EACL,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAQpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAiCnD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,MAAM,GACrB,MAAM,CA8BR;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAgB,IAAI,mBAAmB;gBAC3B,UAAU,EAAE,MAAM;CAM/B;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAgB,IAAI,EAAE,mBAAmB,GAAG,qBAAqB,CAAC;gBACtD,IAAI,EAAE,mBAAmB,GAAG,qBAAqB,EAAE,OAAO,EAAE,MAAM;CAK/E;AAED,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,EAAE,CAAW;IACrB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,cAAc,CAA6B;gBAEvC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAE,eAAoB;IAgBxE;;OAEG;IACH,KAAK,IAAI,IAAI;IAwBb;;OAEG;IACH,IAAI,IAAI,IAAI;IAeZ;;;;;;;;;OASG;YACW,IAAI;IA2BlB;;;;;;;;;;;;;OAaG;YACW,eAAe;IA8E7B;;;;;;;;;;;;;OAaG;IACG,kBAAkB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,UAAU,CAAC;QAAC,WAAW,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAuC/F;;;;;;;;;;;;;;;OAeG;YACW,0BAA0B;IAsCxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;YACW,qBAAqB;IA2NnC;;;OAGG;YACW,sBAAsB;IAuBpC;;;;;;;;OAQG;YACW,sBAAsB;CAyBrC"}
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAkB9D,OAAO,KAAK,EACV,MAAM,EAGN,QAAQ,EACR,UAAU,EACV,OAAO,EAEP,QAAQ,EAER,IAAI,EACL,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAQpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAiCnD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,MAAM,GACrB,MAAM,CA8BR;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAgB,IAAI,mBAAmB;gBAC3B,YAAY,EAAE,MAAM;CAMjC;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAgB,IAAI,EAAE,mBAAmB,GAAG,qBAAqB,CAAC;gBACtD,IAAI,EAAE,mBAAmB,GAAG,qBAAqB,EAAE,OAAO,EAAE,MAAM;CAK/E;AAED,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,kIAAkI;IAClI,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC9B;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,EAAE,CAA2B;IACrC,OAAO,CAAC,MAAM,CAAkF;IAChG,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,cAAc,CAA6B;gBAEvC,EAAE,EAAE,wBAAwB,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAE,eAAoB;IAoBxF;;OAEG;IACH,KAAK,IAAI,IAAI;IAwBb;;OAEG;IACH,IAAI,IAAI,IAAI;IAeZ;;;;;;;;;OASG;YACW,IAAI;YAsCJ,mBAAmB;IAoBjC;;;;;;;;;;;;;OAaG;YACW,eAAe;IA8E7B;;;;;;;;;;;;;OAaG;IACG,kBAAkB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,UAAU,CAAC;QAAC,WAAW,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAuC/F;;;;;;;;;;;;;;;OAeG;YACW,0BAA0B;IAsCxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;YACW,qBAAqB;IA4NnC;;;OAGG;YACW,sBAAsB;IAuBpC;;;;;;;;OAQG;YACW,sBAAsB;CAyBrC"}

package/dist/daemon/services/scheduler.js

@@ -2,7 +2,10 @@
 import {
   advisoryLockKeyForUuid,
   BranchRepository,
+  getCurrentTenantId,
   isPostgresDatabase,
+  runWithSystemDatabaseScope,
+  runWithTenantDatabaseScope,
   ScheduleRepository,
   SessionMCPServerRepository,
   SessionRepository,
@@ -69,9 +72,9 @@ function renderSchedulePrompt(template, branch, schedule, scheduledRunAt) {
 }
 var ScheduleBusyError = class extends Error {
   code = "schedule_busy";
-  constructor(branchName) {
+  constructor(scheduleName) {
     super(
-      `A session is already running in branch "${branchName}" and allow_concurrent_runs is disabled.`
+      `An active run from schedule "${scheduleName}" is already in progress and allow_concurrent_runs is disabled.`
     );
     this.name = "ScheduleBusyError";
   }
@@ -104,7 +107,8 @@ var SchedulerService = class {
       gracePeriod: config.gracePeriod ?? 12e4,
       // 2 minutes
       debug: config.debug ?? false,
-      unixUserMode: config.unixUserMode ?? "simple"
+      unixUserMode: config.unixUserMode ?? "simple",
+      tenantId: typeof config.tenantId === "string" && config.tenantId.trim() ? config.tenantId.trim() : void 0
     };
     this.branchRepo = new BranchRepository(db);
     this.scheduleRepo = new ScheduleRepository(db);
@@ -161,18 +165,25 @@ var SchedulerService = class {
   async tick() {
     const now = Date.now();
     try {
-      const dueSchedules = await this.scheduleRepo.findDue(now + this.config.gracePeriod);
+      const dueScheduleRefs = await this.findDueScheduleRefs(now);
       if (this.config.debug) {
-        console.log(`\u{1F504} Scheduler tick: Found ${dueSchedules.length} due schedules`);
+        console.log(`\u{1F504} Scheduler tick: Found ${dueScheduleRefs.length} due schedules`);
       }
-      for (const schedule of dueSchedules) {
-        try {
-          await this.processSchedule(schedule, now);
-        } catch (error) {
+      for (const ref of dueScheduleRefs) {
+        if (!ref.tenantId) {
           console.error(
-            `\u274C Failed to process schedule ${schedule.schedule_id} (${schedule.name}):`,
-            error
+            `\u274C Skipping due schedule ${shortId(ref.scheduleId)}: missing tenant metadata`
           );
+          continue;
+        }
+        try {
+          await runWithTenantDatabaseScope(this.db, ref.tenantId, async () => {
+            const schedule = await this.scheduleRepo.findById(ref.scheduleId);
+            if (!schedule) return;
+            await this.processSchedule(schedule, now);
+          });
+        } catch (error) {
+          console.error(`\u274C Failed to process schedule ${shortId(ref.scheduleId)}:`, error);
         }
       }
     } catch (error) {
@@ -180,6 +191,23 @@ var SchedulerService = class {
       throw error;
     }
   }
+  async findDueScheduleRefs(now) {
+    const findDue = async (tenantId) => {
+      const dueSchedules = await this.scheduleRepo.findDueRefs(now + this.config.gracePeriod);
+      return dueSchedules.map((schedule) => ({
+        scheduleId: schedule.schedule_id,
+        tenantId: tenantId ?? schedule.tenant_id
+      }));
+    };
+    if (this.config.tenantId) {
+      return runWithTenantDatabaseScope(
+        this.db,
+        this.config.tenantId,
+        () => findDue(this.config.tenantId)
+      );
+    }
+    return runWithSystemDatabaseScope(this.db, "scheduler due schedule discovery", () => findDue());
+  }
   /**
    * Process a single schedule.
    *
@@ -255,7 +283,7 @@ var SchedulerService = class {
    * @throws ScheduleNotReadyError when the schedule is disabled or its
    *   branch can't be loaded.
    * @throws ScheduleBusyError when allow_concurrent_runs is false and
-   *   the branch already has an active session.
+   *   this schedule already has an active run.
    */
   async executeScheduleNow(opts) {
     const { scheduleId, triggeredBy } = opts;
@@ -350,9 +378,9 @@ var SchedulerService = class {
    * 1. Look up the schedule's branch (cascaded delete means it should
    *    always exist; we still handle null defensively).
    * 2. Dedup against `sessions(schedule_id, scheduled_run_at)`.
-   * 3. Enforce `allow_concurrent_runs` against any active session in the
-   *    SAME BRANCH (sibling schedules on the same branch are sequential
-   *    by default; opt out per-schedule via allow_concurrent_runs).
+   * 3. Enforce `allow_concurrent_runs` against any active session spawned
+   *    by the SAME SCHEDULE. Different schedules on the same branch do not
+   *    block one another.
    * 4. Render prompt template (Handlebars).
    * 5. Look up creator's unix_username for execution context.
    * 6. Create session with schedule metadata + `schedule_id` FK.
@@ -365,13 +393,10 @@ var SchedulerService = class {
    * 9. Enforce retention policy (oldest sessions on this schedule_id
    *    are deleted).
    *
-   * NOTE (multi-daemon, deferred): with the current per-schedule
-   * advisory lock, two daemons can each lock different schedules on
-   * the same branch and both pass the branch-wide concurrency guard
-   * before either creates a session, then both spawn. Branch-scoped
-   * coordination (lock on branch when allow_concurrent_runs=false)
-   * will be needed once we support multi-daemon. Out of scope for V1
-   * since multi-daemon isn't supported yet.
+   * NOTE (multi-daemon, deferred): the per-schedule advisory lock and
+   * partial unique index guard same-schedule races. They deliberately do
+   * not serialize sibling schedules on the same branch, matching the
+   * schedule-scoped meaning of `allow_concurrent_runs=false`.
    */
   async spawnScheduledSession(schedule, scheduledRunAt, now, options = { source: "cron" }) {
     const { source, triggeredBy } = options;
@@ -395,19 +420,19 @@ var SchedulerService = class {
       return existingSession;
     }
     if (!schedule.allow_concurrent_runs) {
-      const active = await this.sessionRepo.existsInBranchWithStatuses(
-        branch.branch_id,
+      const active = await this.sessionRepo.existsInScheduleWithStatuses(
+        schedule.schedule_id,
         ACTIVE_SESSION_STATUSES
       );
       if (active) {
         if (manual) {
           console.log(
-            `   \u26D4 ${schedule.name}: manual run blocked \u2014 active session present (allow_concurrent_runs=false)`
+            `   \u26D4 ${schedule.name}: manual run blocked \u2014 active run from this schedule present (allow_concurrent_runs=false)`
           );
-          throw new ScheduleBusyError(branch.name);
+          throw new ScheduleBusyError(schedule.name);
         }
         console.log(
-          `   \u23ED\uFE0F  ${schedule.name}: scheduled run skipped \u2014 active session present (allow_concurrent_runs=false)`
+          `   \u23ED\uFE0F  ${schedule.name}: scheduled run skipped \u2014 active run from this schedule present (allow_concurrent_runs=false)`
         );
         await this.updateScheduleMetadata(schedule, scheduledRunAt, null, now);
         return null;
@@ -510,6 +535,7 @@ var SchedulerService = class {
         }
       }
       const promptService = this.app.service("/sessions/:id/prompt");
+      const tenantId = getCurrentTenantId();
       await promptService.create(
         {
           prompt: renderedPrompt,
@@ -520,8 +546,9 @@ var SchedulerService = class {
           route: { id: createdSession.session_id },
           provider: void 0,
           // Bypass auth for internal scheduler call
-          user: creator
+          user: creator,
           // Pass creator user for session token generation
+          ...tenantId ? { tenant: { tenant_id: tenantId, source: "explicit" } } : {}
         }
       );
       await this.updateScheduleMetadata(

package/dist/daemon/services/schedules.d.ts

@@ -13,7 +13,7 @@
  *
  * See docs/internal/schedules-first-class-design-2026-05-24.md §4.4.
  */
-import { type Database } from '@agor/core/db';
+import { type TenantScopeAwareDatabase } from '@agor/core/db';
 import type { AuthenticatedParams, BranchID, QueryParams, Schedule, UUID } from '@agor/core/types';
 import { DrizzleService } from '../adapters/drizzle';
 export type ScheduleParams = QueryParams<{
@@ -22,7 +22,7 @@ export type ScheduleParams = QueryParams<{
     created_by?: UUID;
 }> & AuthenticatedParams;
 export declare class SchedulesService extends DrizzleService<Schedule, Partial<Schedule>, ScheduleParams> {
-    constructor(db: Database);
+    constructor(db: TenantScopeAwareDatabase);
 }
-export declare function createSchedulesService(db: Database): SchedulesService;
+export declare function createSchedulesService(db: TenantScopeAwareDatabase): SchedulesService;
 //# sourceMappingURL=schedules.d.ts.map