comisai 1.0.34 → 1.0.37

package/node_modules/@comis/memory/dist/oauth-profile-store-encrypted.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Encrypted SQLite-backed OAuthCredentialStorePort adapter.
+ *
+ * Mirrors credential-mapping-store's factory pattern (takes a pre-opened
+ * Database instance, does NOT open its own). The lifecycle is owned by
+ * the caller — we share the existing secrets.db connection to keep all
+ * encrypted-at-rest data in one DB file.
+ *
+ * The entire OAuthProfile JSON payload is encrypted as one AES-256-GCM
+ * blob per row. One ciphertext+iv+authTag+salt set per profile. Atomic
+ * update — no half-rotated state where access changes but refresh doesn't.
+ *
+ * Denormalized expires_at column stays in sync on every write so the
+ * doctor can query expiring profiles without decrypting any blob.
+ *
+ * @module
+ */
+import type Database from "better-sqlite3";
+import type { OAuthCredentialStorePort, SecretsCrypto } from "@comis/core";
+/**
+ * Create an encrypted OAuthCredentialStorePort backed by a shared SQLite DB.
+ *
+ * The adapter does NOT own the db lifecycle — the caller supplies an
+ * already-open Database (typically the secrets.db chain). Initializes its
+ * own oauth_profiles table via initOAuthProfileSchema (idempotent).
+ */
+export declare function createOAuthProfileStoreEncrypted(db: Database.Database, crypto: SecretsCrypto): OAuthCredentialStorePort;

package/node_modules/@comis/memory/dist/oauth-profile-store-encrypted.js

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Encrypted SQLite-backed OAuthCredentialStorePort adapter.
+ *
+ * Mirrors credential-mapping-store's factory pattern (takes a pre-opened
+ * Database instance, does NOT open its own). The lifecycle is owned by
+ * the caller — we share the existing secrets.db connection to keep all
+ * encrypted-at-rest data in one DB file.
+ *
+ * The entire OAuthProfile JSON payload is encrypted as one AES-256-GCM
+ * blob per row. One ciphertext+iv+authTag+salt set per profile. Atomic
+ * update — no half-rotated state where access changes but refresh doesn't.
+ *
+ * Denormalized expires_at column stays in sync on every write so the
+ * doctor can query expiring profiles without decrypting any blob.
+ *
+ * @module
+ */
+import { ok, err, fromPromise } from "@comis/shared";
+import { validateProfileId } from "@comis/core";
+import { initOAuthProfileSchema } from "./oauth-profile-schema.js";
+const SCHEMA_VERSION = 1;
+/**
+ * Create an encrypted OAuthCredentialStorePort backed by a shared SQLite DB.
+ *
+ * The adapter does NOT own the db lifecycle — the caller supplies an
+ * already-open Database (typically the secrets.db chain). Initializes its
+ * own oauth_profiles table via initOAuthProfileSchema (idempotent).
+ */
+export function createOAuthProfileStoreEncrypted(db, crypto) {
+    initOAuthProfileSchema(db);
+    const upsertStmt = db.prepare(`
+    INSERT INTO oauth_profiles (
+      profile_id, provider, identity,
+      credentials_ciphertext, credentials_iv, credentials_auth_tag, credentials_salt,
+      expires_at, version, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(profile_id) DO UPDATE SET
+      provider = excluded.provider,
+      identity = excluded.identity,
+      credentials_ciphertext = excluded.credentials_ciphertext,
+      credentials_iv = excluded.credentials_iv,
+      credentials_auth_tag = excluded.credentials_auth_tag,
+      credentials_salt = excluded.credentials_salt,
+      expires_at = excluded.expires_at,
+      version = excluded.version,
+      updated_at = excluded.updated_at
+  `);
+    const getStmt = db.prepare("SELECT * FROM oauth_profiles WHERE profile_id = ?");
+    const deleteStmt = db.prepare("DELETE FROM oauth_profiles WHERE profile_id = ?");
+    const listAllStmt = db.prepare("SELECT * FROM oauth_profiles");
+    const listByProviderStmt = db.prepare("SELECT * FROM oauth_profiles WHERE provider = ?");
+    const existsStmt = db.prepare("SELECT 1 FROM oauth_profiles WHERE profile_id = ?");
+    function rowToProfile(row) {
+        if (row.version !== SCHEMA_VERSION) {
+            return err(new Error("OAuth profile store version mismatch: expected " +
+                SCHEMA_VERSION +
+                ", got " +
+                String(row.version) +
+                ". Hint: drop the oauth_profiles table and re-run `comis auth login` to recreate. Stored profiles for unknown schema versions cannot be migrated."));
+        }
+        const decryptResult = crypto.decrypt({
+            ciphertext: row.credentials_ciphertext,
+            iv: row.credentials_iv,
+            authTag: row.credentials_auth_tag,
+            salt: row.credentials_salt,
+        });
+        if (!decryptResult.ok)
+            return err(decryptResult.error);
+        let parsed;
+        try {
+            parsed = JSON.parse(decryptResult.value);
+        }
+        catch (e) {
+            return err(new Error("OAuth profile decryption produced invalid JSON: " + String(e)));
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return err(new Error("OAuth profile decryption produced non-object payload"));
+        }
+        return ok(parsed);
+    }
+    const port = {
+        async get(profileId) {
+            const validation = validateProfileId(profileId);
+            if (!validation.ok)
+                return err(validation.error);
+            return fromPromise((async () => {
+                const row = getStmt.get(profileId);
+                if (!row)
+                    return undefined;
+                const r = rowToProfile(row);
+                if (!r.ok)
+                    throw r.error;
+                return r.value;
+            })());
+        },
+        async set(profileId, profile) {
+            const validation = validateProfileId(profileId);
+            if (!validation.ok)
+                return err(validation.error);
+            const fullProfile = { ...profile, profileId, version: SCHEMA_VERSION };
+            const payload = JSON.stringify(fullProfile);
+            const encryptResult = crypto.encrypt(payload);
+            if (!encryptResult.ok)
+                return err(encryptResult.error);
+            const enc = encryptResult.value;
+            const now = Date.now();
+            return fromPromise((async () => {
+                upsertStmt.run(profileId, validation.value.provider, validation.value.identity, enc.ciphertext, enc.iv, enc.authTag, enc.salt, fullProfile.expires, SCHEMA_VERSION, now, now);
+            })());
+        },
+        async delete(profileId) {
+            const validation = validateProfileId(profileId);
+            if (!validation.ok)
+                return err(validation.error);
+            return fromPromise((async () => {
+                const result = deleteStmt.run(profileId);
+                return result.changes > 0;
+            })());
+        },
+        async list(filter) {
+            return fromPromise((async () => {
+                const rows = filter?.provider
+                    ? listByProviderStmt.all(filter.provider)
+                    : listAllStmt.all();
+                const profiles = [];
+                for (const row of rows) {
+                    const r = rowToProfile(row);
+                    if (!r.ok)
+                        throw r.error;
+                    profiles.push(r.value);
+                }
+                return profiles;
+            })());
+        },
+        async has(profileId) {
+            const validation = validateProfileId(profileId);
+            if (!validation.ok)
+                return err(validation.error);
+            return fromPromise((async () => existsStmt.get(profileId) !== undefined)());
+        },
+    };
+    return Object.freeze(port);
+}

package/node_modules/@comis/memory/dist/session-store.d.ts

@@ -5,7 +5,7 @@
  * prepared statements. Sessions survive process restarts since they are
  * stored in SQLite.
  *
- * Factory function pattern (createSessionStore) consistent with Phase 1
+ * Factory function pattern (createSessionStore) consistent with
  * createSecretManager for minimal public surface area.
  */
 import type Database from "better-sqlite3";

package/node_modules/@comis/memory/dist/session-store.js

@@ -6,7 +6,7 @@
  * prepared statements. Sessions survive process restarts since they are
  * stored in SQLite.
  *
- * Factory function pattern (createSessionStore) consistent with Phase 1
+ * Factory function pattern (createSessionStore) consistent with
  * createSecretManager for minimal public surface area.
  */
 import { formatSessionKey } from "@comis/core";

package/node_modules/@comis/memory/dist/sqlite-secret-store.d.ts

@@ -10,7 +10,32 @@
  *
  * Persists encrypted secrets across daemon restarts.
  */
+import type Database from "better-sqlite3";
 import type { SecretStorePort, SecretsCrypto } from "@comis/core";
+/**
+ * Concrete return type of createSqliteSecretStore.
+ *
+ * Implements SecretStorePort and additionally exposes the underlying
+ * better-sqlite3 handle for adapters that need to share the same
+ * connection (e.g., the encrypted OAuth profile store).
+ *
+ * The `db` field is intentionally additive — `SecretStorePort` itself is
+ * unchanged and remains the canonical port boundary. Consumers that only
+ * need port-level operations should accept `SecretStorePort`, not
+ * `SqliteSecretStoreHandle`.
+ */
+export interface SqliteSecretStoreHandle extends SecretStorePort {
+    /**
+     * Underlying better-sqlite3 handle.
+     *
+     * Use for sharing the connection with sibling tables in the same DB
+     * file (e.g., `oauth_profiles` alongside `secrets`). Eliminates the
+     * dual-handle hazard (close-order, schema-init double-execution,
+     * prepared-statement cache fragmentation) that two separate handles
+     * to the same WAL-mode SQLite file would introduce.
+     */
+    readonly db: Database.Database;
+}
 /**
  * Create a SqliteSecretStore bound to the given database path.
  *
@@ -22,11 +47,12 @@ import type { SecretStorePort, SecretsCrypto } from "@comis/core";
  * 5. Validate canary (master key mismatch detection)
  * 6. Second chmod pass (SQLite may create WAL/SHM during canary)
  * 7. Prepare all SQL statements once
- * 8. Return frozen SecretStorePort object
+ * 8. Return frozen SqliteSecretStoreHandle (SecretStorePort + db field)
  *
  * @param dbPath - Absolute path to the secrets.db file
  * @param crypto - SecretsCrypto engine bound to the current master key
- * @returns SecretStorePort implementation
+ * @returns SqliteSecretStoreHandle — a SecretStorePort that also exposes
+ *          the underlying better-sqlite3 handle on `.db`
  * @throws Error if schema init, canary validation, or DB open fails
  */
-export declare function createSqliteSecretStore(dbPath: string, crypto: SecretsCrypto): SecretStorePort;
+export declare function createSqliteSecretStore(dbPath: string, crypto: SecretsCrypto): SqliteSecretStoreHandle;

package/node_modules/@comis/memory/dist/sqlite-secret-store.js

@@ -25,11 +25,12 @@ import { openSqliteDatabase, chmodDbFiles } from "./sqlite-adapter-base.js";
  * 5. Validate canary (master key mismatch detection)
  * 6. Second chmod pass (SQLite may create WAL/SHM during canary)
  * 7. Prepare all SQL statements once
- * 8. Return frozen SecretStorePort object
+ * 8. Return frozen SqliteSecretStoreHandle (SecretStorePort + db field)
  *
  * @param dbPath - Absolute path to the secrets.db file
  * @param crypto - SecretsCrypto engine bound to the current master key
- * @returns SecretStorePort implementation
+ * @returns SqliteSecretStoreHandle — a SecretStorePort that also exposes
+ *          the underlying better-sqlite3 handle on `.db`
  * @throws Error if schema init, canary validation, or DB open fails
  */
 export function createSqliteSecretStore(dbPath, crypto) {
@@ -149,5 +150,12 @@ export function createSqliteSecretStore(dbPath, crypto) {
             db.close();
         },
     };
-    return Object.freeze(store);
+    // Expose the underlying db handle on the factory return so the encrypted
+    // OAuth profile adapter (oauth-profile-store-encrypted) can share this same
+    // connection rather than opening a second handle to the same secrets.db
+    // file. The SecretStorePort surface itself is unchanged — consumers that
+    // only need port-level operations should accept SecretStorePort, not
+    // SqliteSecretStoreHandle.
+    const handle = { ...store, db };
+    return Object.freeze(handle);
 }

package/node_modules/@comis/memory/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comis/memory",
   "private": true,
-  "version": "1.0.34",
+  "version": "1.0.37",
   "author": "Moshe Anconina",
   "license": "Apache-2.0",
   "description": "SQLite memory, embeddings, and RAG storage for Comis agents",

package/node_modules/@comis/scheduler/dist/cron/cron-types.d.ts

@@ -8,19 +8,14 @@ import { z } from "zod";
  */
 export declare const CronScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"cron">;
-    /** Standard cron expression (5 or 6 fields) */
     expr: z.ZodString;
-    /** IANA timezone (e.g. "America/New_York"), omit for UTC */
     tz: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"every">;
-    /** Interval in milliseconds */
     everyMs: z.ZodNumber;
-    /** Optional anchor timestamp in ms (first tick aligned to this) */
     anchorMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"at">;
-    /** ISO 8601 datetime string for one-shot execution */
     at: z.ZodString;
 }, z.core.$strict>], "kind">;
 export type CronSchedule = z.infer<typeof CronScheduleSchema>;
@@ -32,15 +27,11 @@ export type CronSchedule = z.infer<typeof CronScheduleSchema>;
  */
 export declare const CronPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"system_event">;
-    /** Event text to emit */
     text: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"agent_turn">;
-    /** Message to send to the agent */
     message: z.ZodString;
-    /** Optional model override for this turn */
     model: z.ZodOptional<z.ZodString>;
-    /** Optional timeout in seconds for this turn */
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>], "kind">;
 export type CronPayload = z.infer<typeof CronPayloadSchema>;
@@ -80,99 +71,66 @@ export type CronDeliveryTarget = z.infer<typeof CronDeliveryTargetSchema>;
  * Full cron job definition.
  */
 export declare const CronJobSchema: z.ZodObject<{
-    /** Unique job identifier */
     id: z.ZodString;
-    /** Human-readable job name */
     name: z.ZodString;
-    /** Agent ID that owns this job */
     agentId: z.ZodString;
-    /** Schedule definition */
     schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"cron">;
-        /** Standard cron expression (5 or 6 fields) */
         expr: z.ZodString;
-        /** IANA timezone (e.g. "America/New_York"), omit for UTC */
         tz: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"every">;
-        /** Interval in milliseconds */
         everyMs: z.ZodNumber;
-        /** Optional anchor timestamp in ms (first tick aligned to this) */
         anchorMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"at">;
-        /** ISO 8601 datetime string for one-shot execution */
         at: z.ZodString;
     }, z.core.$strict>], "kind">;
-    /** Payload to execute */
     payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"system_event">;
-        /** Event text to emit */
         text: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"agent_turn">;
-        /** Message to send to the agent */
         message: z.ZodString;
-        /** Optional model override for this turn */
         model: z.ZodOptional<z.ZodString>;
-        /** Optional timeout in seconds for this turn */
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>], "kind">;
-    /** Session target for execution */
     sessionTarget: z.ZodDefault<z.ZodEnum<{
         main: "main";
         isolated: "isolated";
     }>>;
-    /** Wake mode: when to trigger heartbeat after enqueuing a system event. */
     wakeMode: z.ZodDefault<z.ZodEnum<{
         now: "now";
         "next-heartbeat": "next-heartbeat";
     }>>;
-    /** Whether to forward isolated session results back to main heartbeat session. */
     forwardToMain: z.ZodDefault<z.ZodBoolean>;
-    /** Session history strategy for cron executions. Default: fresh. */
     sessionStrategy: z.ZodDefault<z.ZodEnum<{
         fresh: "fresh";
         rolling: "rolling";
         accumulate: "accumulate";
     }>>;
-    /** Number of recent turns to keep for rolling strategy (default 3). */
     maxHistoryTurns: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    /** Per-job cache retention override. Default inherits OPERATION_CACHE_DEFAULTS["cron"] = "short". */
     cacheRetention: z.ZodOptional<z.ZodEnum<{
         none: "none";
         short: "short";
         long: "long";
     }>>;
-    /** Per-job tool policy override -- matches AgentConfig.toolPolicy shape.
-     *
-     *  Resolution order: job.toolPolicy > agentConfig.toolPolicy > passthrough
-     *  (no filtering). Opt-in: omitting this field preserves existing tool set
-     *  for the job. No silent defaults -- operators explicitly request
-     *  conservative presets like `{ profile: "cron-minimal" }`. */
     toolPolicy: z.ZodOptional<z.ZodObject<{
         profile: z.ZodDefault<z.ZodString>;
         allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
         deny: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-    /** Delivery target for routing results to originating channel */
     deliveryTarget: z.ZodOptional<z.ZodObject<{
         channelId: z.ZodString;
         userId: z.ZodString;
         tenantId: z.ZodString;
         channelType: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
-    /** Whether this job is currently enabled */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Next scheduled run timestamp (ms since epoch) */
     nextRunAtMs: z.ZodOptional<z.ZodNumber>;
-    /** Last completed run timestamp (ms since epoch) */
     lastRunAtMs: z.ZodOptional<z.ZodNumber>;
-    /** Number of consecutive errors */
     consecutiveErrors: z.ZodDefault<z.ZodNumber>;
-    /** Maximum consecutive errors before auto-suspend. Per-job override of scheduler default. */
     maxConsecutiveErrors: z.ZodOptional<z.ZodNumber>;
-    /** Job creation timestamp (ms since epoch) */
     createdAtMs: z.ZodNumber;
 }, z.core.$strict>;
 export type CronJob = z.infer<typeof CronJobSchema>;

package/node_modules/@comis/scheduler/dist/execution/execution-lock.d.ts

@@ -14,6 +14,19 @@ export interface ExecutionLockOptions {
     updateMs: number;
     /** Callback when lock is compromised (e.g., external release). */
     onCompromised?: (err: Error) => void;
+    /**
+     * Optional lock-acquisition retry budget. Forwarded to proper-lockfile's
+     * own retry option (uses a built-in incremental backoff). When undefined
+     * (default), retries: 0 — fail fast on contention. Lets the OAuth manager
+     * wait for a sibling refresh to complete (concurrent-refresh acceptance)
+     * without callers having to roll their own retry loop.
+     */
+    retries?: number | {
+        retries: number;
+        minTimeout?: number;
+        maxTimeout?: number;
+        factor?: number;
+    };
 }
 /**
  * Acquire a file lock, execute the function, and release the lock.

package/node_modules/@comis/scheduler/dist/execution/execution-lock.js

@@ -41,7 +41,7 @@ export async function withExecutionLock(lockPath, fn, options) {
         release = await lockfile.lock(lockPath, {
             stale: opts.staleMs,
             update: opts.updateMs,
-            retries: 0,
+            retries: opts.retries ?? 0,
             onCompromised: opts.onCompromised ?? (() => { }),
         });
     }

package/node_modules/@comis/scheduler/dist/execution/index.d.ts

@@ -1,2 +1,4 @@
 export { createExecutionTracker } from "./execution-tracker.js";
 export type { ExecutionTracker, ExecutionLogEntry } from "./execution-tracker.js";
+export { withExecutionLock, isLocked } from "./execution-lock.js";
+export type { ExecutionLockOptions } from "./execution-lock.js";

package/node_modules/@comis/scheduler/dist/execution/index.js

@@ -2,3 +2,5 @@
 // @comis/scheduler/execution — execution safety primitives
 // Execution tracking
 export { createExecutionTracker } from "./execution-tracker.js";
+// File-based execution lock
+export { withExecutionLock, isLocked } from "./execution-lock.js";

package/node_modules/@comis/scheduler/dist/heartbeat/agent-heartbeat-source.d.ts

@@ -37,9 +37,19 @@ interface HeartbeatExecutor {
         response: string;
     }>;
 }
-/** Minimal ActiveRunRegistry -- only needs has() for queue-busy check. */
-interface HeartbeatActiveRunRegistry {
-    has(sessionKey: string): boolean;
+/**
+ * Minimal BackgroundSessionResolver shape -- only needs hasActiveSession()
+ * for the queue-busy check. The scheduler package cannot import @comis/agent
+ * (would create a cycle), so we re-declare the structural minimum here. The
+ * daemon wires `createBackgroundSessionResolver({activeRunRegistry})` and
+ * the resulting object is structurally assignable to this shape (R3, B36).
+ */
+interface HeartbeatSessionResolver {
+    hasActiveSession(key: {
+        agentId: string;
+        channelType: string;
+        channelId: string;
+    }): boolean;
 }
 /** Tool policy filter function signature -- matches applyToolPolicy from @comis/skills.
  *  Injected as a dep so scheduler doesn't take a hard dependency on skills. */
@@ -96,8 +106,12 @@ export interface AgentHeartbeatSourceDeps {
     systemEventQueue: SystemEventQueue;
     /** Delivery bridge dependencies for routing notifications. */
     deliveryBridge: DeliveryBridgeDeps;
-    /** Optional ActiveRunRegistry for queue-busy detection. */
-    activeRunRegistry?: HeartbeatActiveRunRegistry;
+    /**
+     * Optional composite-key resolver for queue-busy detection (R3, B36).
+     * Wired by the daemon as
+     * `createBackgroundSessionResolver({activeRunRegistry})`.
+     */
+    sessionResolver?: HeartbeatSessionResolver;
     /** Optional session operations for response processing side-effects. */
     sessionOps?: HeartbeatSessionOps;
     /** Optional: fetch memory stats for an agent (for heartbeat prompt injection). */
@@ -119,12 +133,19 @@ export interface AgentHeartbeatSourceDeps {
  */
 export declare function resolveHeartbeatModel(perAgentHeartbeatModel: string | undefined, globalHeartbeatModel: string | undefined, agentDefaultModel: string): string;
 /**
- * Check if a session is actively running an agent turn.
+ * Check if a session is actively running an agent turn (R3, B36).
  *
- * Returns false when no ActiveRunRegistry is provided (heartbeat
+ * Uses the composite-key resolver: `(agentId, channelType, channelId)`
+ * uniquely identifies a session across multi-agent / multi-channel
+ * deployments (the previous single-arg `formattedKey` collapsed those
+ * dimensions). Returns false when no resolver is provided (heartbeat
  * operates in isolation without collision detection).
  */
-export declare function isQueueBusy(activeRunRegistry: HeartbeatActiveRunRegistry | undefined, sessionKey: string): boolean;
+export declare function isQueueBusy(sessionResolver: HeartbeatSessionResolver | undefined, composite: {
+    agentId: string;
+    channelType: string;
+    channelId: string;
+}): boolean;
 /**
  * Resolve the SessionKey for a heartbeat tick.
  *

package/node_modules/@comis/scheduler/dist/heartbeat/agent-heartbeat-source.js

@@ -41,15 +41,18 @@ export function resolveHeartbeatModel(perAgentHeartbeatModel, globalHeartbeatMod
     return perAgentHeartbeatModel ?? globalHeartbeatModel ?? agentDefaultModel;
 }
 /**
- * Check if a session is actively running an agent turn.
+ * Check if a session is actively running an agent turn (R3, B36).
  *
- * Returns false when no ActiveRunRegistry is provided (heartbeat
+ * Uses the composite-key resolver: `(agentId, channelType, channelId)`
+ * uniquely identifies a session across multi-agent / multi-channel
+ * deployments (the previous single-arg `formattedKey` collapsed those
+ * dimensions). Returns false when no resolver is provided (heartbeat
  * operates in isolation without collision detection).
  */
-export function isQueueBusy(activeRunRegistry, sessionKey) {
-    if (!activeRunRegistry)
+export function isQueueBusy(sessionResolver, composite) {
+    if (!sessionResolver)
         return false;
-    return activeRunRegistry.has(sessionKey);
+    return sessionResolver.hasActiveSession(composite);
 }
 /**
  * Resolve the SessionKey for a heartbeat tick.
@@ -99,8 +102,17 @@ export function createAgentHeartbeatSource(deps) {
                     return;
                 }
             }
-            // 5. Queue-busy check
-            if (isQueueBusy(deps.activeRunRegistry, formattedKey)) {
+            // 5. Queue-busy check (R3, B36): composite-key lookup distinguishes
+            // multi-agent / multi-channel collisions. The msg.channelType is the
+            // configured target's channelType (defaulting to "heartbeat" when no
+            // delivery target is wired). channelId is sessionKey.channelId
+            // (matches resolveHeartbeatSessionKey above).
+            const heartbeatChannelType = config.target?.channelType ?? "heartbeat";
+            if (isQueueBusy(deps.sessionResolver, {
+                agentId,
+                channelType: heartbeatChannelType,
+                channelId: sessionKey.channelId,
+            })) {
                 logger.debug({ agentId, formattedKey }, "Heartbeat skipped: session queue busy");
                 return;
             }
@@ -158,7 +170,7 @@ export function createAgentHeartbeatSource(deps) {
                 },
             };
             // 9. Resolve model (for logging)
-            const model = resolveHeartbeatModel(undefined, // per-agent heartbeat model removed in Phase 2
+            const model = resolveHeartbeatModel(undefined, // per-agent heartbeat model not in schema
             undefined, // global heartbeat model not yet in schema
             agentConfig.model);
             logger.info({ agentId, trigger, model, channelType: msg.channelType }, "Heartbeat run starting");

package/node_modules/@comis/scheduler/dist/index.d.ts

@@ -7,6 +7,8 @@ export { createCronScheduler } from "./cron/index.js";
 export type { CronScheduler } from "./cron/index.js";
 export { createExecutionTracker } from "./execution/index.js";
 export type { ExecutionTracker, ExecutionLogEntry } from "./execution/index.js";
+export { withExecutionLock, isLocked } from "./execution/execution-lock.js";
+export type { ExecutionLockOptions } from "./execution/execution-lock.js";
 export { HEARTBEAT_OK_TOKEN, createHeartbeatRunner } from "./heartbeat/index.js";
 export type { HeartbeatCheckResult, HeartbeatSourcePort, HeartbeatRunner } from "./heartbeat/index.js";
 export { resolveEffectiveHeartbeatConfig } from "./heartbeat/index.js";

package/node_modules/@comis/scheduler/dist/index.js

@@ -7,6 +7,8 @@ export { createCronStore } from "./cron/index.js";
 export { createCronScheduler } from "./cron/index.js";
 // Execution safety
 export { createExecutionTracker } from "./execution/index.js";
+// File-based execution lock (consumed by @comis/agent OAuth file adapter + token manager)
+export { withExecutionLock, isLocked } from "./execution/execution-lock.js";
 // Heartbeat monitoring
 export { HEARTBEAT_OK_TOKEN, createHeartbeatRunner } from "./heartbeat/index.js";
 // Per-agent heartbeat config resolution

package/node_modules/@comis/scheduler/dist/system-events/system-event-types.d.ts

@@ -4,11 +4,8 @@ import { z } from "zod";
  * Events are produced by subsystems (cron, exec) and consumed by the heartbeat cycle.
  */
 export declare const SystemEventEntrySchema: z.ZodObject<{
-    /** Event text content (e.g., "Check disk space", "Command completed: git pull") */
     text: z.ZodString;
-    /** Classification key for filtering (e.g., "cron:job-abc", "exec:cmd-123") */
     contextKey: z.ZodString;
-    /** Timestamp when the event was enqueued (ms since epoch) */
     enqueuedAt: z.ZodNumber;
 }, z.core.$strict>;
 export type SystemEventEntry = z.infer<typeof SystemEventEntrySchema>;