@agent-relay/factory 0.1.62 → 0.1.64

package/dist/state/file-state-store.js

@@ -5,6 +5,7 @@ import lockfile from 'proper-lockfile';
 import { githubRepositoriesMatch } from '../github/repo-identity.js';
 import { InMemoryStateStore } from './in-memory-state-store.js';
 import { matchingGithubLifecycleEntry } from './github-lifecycle-identity.js';
+import { emptyDiscoverySweepState, parseWatchStateDocument } from './watch-state-document.js';
 export const githubWatchStatePath = (registryPath) => join(dirname(registryPath), 'github-issue-comment-watches.json');
 // proper-lockfile refreshes a live writer's lease at half this interval. If a
 // process crashes, the next writer can reclaim its lock after this TTL. The
@@ -14,23 +15,28 @@ export const githubWatchStatePath = (registryPath) => join(dirname(registryPath)
 const WATCH_STATE_LOCK_STALE_MS = 60_000;
 /**
  * Keeps the factory's general runtime bookkeeping in memory while persisting
- * GitHub escalation watches, parked clarification teams, exact babysitter PR
- * ownership, and thread-owned conversation turns atomically so they survive a
- * CLI process restart.
+ * GitHub/Slack escalation watches, parked clarification teams, exact
+ * babysitter PR ownership, and thread-owned conversation turns atomically so
+ * they survive a CLI process restart.
  * Mutations reload under an advisory lock so independent processes merge
  * updates instead of publishing divergent cached documents.
  */
-export class FileStateStore extends InMemoryStateStore {
-    #watchStatePath;
+export class DocumentStateStore extends InMemoryStateStore {
+    backend;
+    #documentStore;
     #batchSize;
     #isProcessAlive;
     #operation = Promise.resolve();
     constructor(options) {
         super(options);
-        this.#watchStatePath = options.watchStatePath;
+        this.backend = options.backend;
+        this.#documentStore = options.documentStore;
         this.#batchSize = options.batchSize;
         this.#isProcessAlive = options.isProcessAlive ?? processIsAlive;
     }
+    async assertReady() {
+        await this.#exclusive(async () => this.#documentStore.assertReady());
+    }
     async claimDiscoverySweep(workspaceId, owner, nowMs, leaseMs) {
         return await this.#exclusive(async () => this.#withMutationLock(async () => {
             const document = await this.#loadFromDisk();
@@ -256,6 +262,33 @@ export class FileStateStore extends InMemoryStateStore {
             await this.#persist(document);
         }));
     }
+    async setSlackThreadWatch(workspaceId, key, watch) {
+        await this.#exclusive(async () => this.#withMutationLock(async () => {
+            const document = await this.#loadFromDisk();
+            const workspace = document.workspaces[workspaceId] ??= emptyWorkspaceState();
+            workspace.slackThreadWatches[key] = structuredClone(watch);
+            await this.#persist(document);
+        }));
+    }
+    async listSlackThreadWatches(workspaceId) {
+        return await this.#exclusive(async () => {
+            const document = await this.#loadFromDisk();
+            return Object.entries(document.workspaces[workspaceId]?.slackThreadWatches ?? {})
+                .map(([key, watch]) => [key, structuredClone(watch)]);
+        });
+    }
+    async clearSlackThreadWatch(workspaceId, key) {
+        await this.#exclusive(async () => this.#withMutationLock(async () => {
+            const document = await this.#loadFromDisk();
+            const workspace = document.workspaces[workspaceId];
+            if (!workspace || !(key in workspace.slackThreadWatches))
+                return;
+            delete workspace.slackThreadWatches[key];
+            if (workspaceIsEmpty(workspace))
+                delete document.workspaces[workspaceId];
+            await this.#persist(document);
+        }));
+    }
     async setGithubIssueCommentWatch(workspaceId, key, watch) {
         await this.#exclusive(async () => {
             await this.#withMutationLock(async () => {
@@ -671,6 +704,90 @@ export class FileStateStore extends InMemoryStateStore {
             return true;
         });
     }
+    async claimConversationMessageAcknowledgement(workspaceId, conversationId, messageId, claimId, nowMs, leaseMs) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (!conversationHasMessage(session, messageId))
+                return false;
+            if ((session.acknowledgedMessageIds ?? []).includes(messageId))
+                return false;
+            session.acknowledgementClaims ??= {};
+            const current = session.acknowledgementClaims[messageId];
+            if (current && current.claimedAtMs + leaseMs > nowMs)
+                return false;
+            session.acknowledgementClaims[messageId] = { claimId, claimedAtMs: nowMs };
+            return true;
+        });
+        return Boolean(result);
+    }
+    async completeConversationMessageAcknowledgement(workspaceId, conversationId, messageId, claimId) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (session.acknowledgementClaims?.[messageId]?.claimId !== claimId)
+                return false;
+            session.acknowledgedMessageIds ??= [];
+            if (!session.acknowledgedMessageIds.includes(messageId))
+                session.acknowledgedMessageIds.push(messageId);
+            delete session.acknowledgementClaims[messageId];
+            return true;
+        });
+        return Boolean(result);
+    }
+    async renewConversationMessageAcknowledgement(workspaceId, conversationId, messageId, claimId, nowMs) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            const claim = session.acknowledgementClaims?.[messageId];
+            if (claim?.claimId !== claimId)
+                return false;
+            claim.claimedAtMs = nowMs;
+            return true;
+        });
+        return Boolean(result);
+    }
+    async releaseConversationMessageAcknowledgement(workspaceId, conversationId, messageId, claimId) {
+        await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (session.acknowledgementClaims?.[messageId]?.claimId !== claimId)
+                return false;
+            delete session.acknowledgementClaims[messageId];
+            return true;
+        });
+    }
+    async claimConversationTerminalReceipt(workspaceId, conversationId, claimId, nowMs, leaseMs) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (session.terminalReceipt?.posted)
+                return false;
+            const current = session.terminalReceipt;
+            if (current && current.claimedAtMs + leaseMs > nowMs)
+                return false;
+            session.terminalReceipt = { claimId, claimedAtMs: nowMs };
+            return true;
+        });
+        return Boolean(result);
+    }
+    async renewConversationTerminalReceipt(workspaceId, conversationId, claimId, nowMs) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            const receipt = session.terminalReceipt;
+            if (receipt?.claimId !== claimId || receipt.posted)
+                return false;
+            receipt.claimedAtMs = nowMs;
+            return true;
+        });
+        return Boolean(result);
+    }
+    async completeConversationTerminalReceipt(workspaceId, conversationId, claimId) {
+        const result = await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (session.terminalReceipt?.claimId !== claimId)
+                return false;
+            session.terminalReceipt = { ...session.terminalReceipt, posted: true };
+            return true;
+        });
+        return Boolean(result);
+    }
+    async releaseConversationTerminalReceipt(workspaceId, conversationId, claimId) {
+        await this.#mutateConversation(workspaceId, conversationId, (session) => {
+            if (session.terminalReceipt?.claimId !== claimId || session.terminalReceipt.posted)
+                return false;
+            delete session.terminalReceipt;
+            return true;
+        });
+    }
     async claimConversationTurn(workspaceId, conversationId, owner, claimId, nowMs, leaseMs) {
         return await this.#mutateConversation(workspaceId, conversationId, (session) => {
             if (session.delivery && session.delivery.claimedAtMs + leaseMs > nowMs) {
@@ -680,10 +797,12 @@ export class FileStateStore extends InMemoryStateStore {
             if (session.delivery)
                 session.pending.unshift(...session.delivery.messages);
             session.pending.sort(compareConversationMessages);
-            if (session.pending.length === 0) {
+            if (!session.agent || session.pending.length === 0) {
+                const hadDelivery = session.delivery !== undefined;
                 session.delivery = undefined;
-                return false;
+                return hadDelivery;
             }
+            const agent = session.agent;
             session.delivery = {
                 claimId,
                 owner,
@@ -691,8 +810,8 @@ export class FileStateStore extends InMemoryStateStore {
                 attempts: attempts + 1,
                 messages: session.pending.splice(0),
                 agent: {
-                    name: session.agent.name,
-                    sessionRef: session.agent.sessionRef,
+                    name: agent.name,
+                    sessionRef: agent.sessionRef,
                 },
             };
             return true;
@@ -712,7 +831,8 @@ export class FileStateStore extends InMemoryStateStore {
             if (!session.delivery || session.delivery.owner !== owner || session.delivery.claimId !== claimId)
                 return false;
             session.history = [...session.history, ...session.delivery.messages].slice(-CONVERSATION_HISTORY_LIMIT);
-            if (session.agent.name === session.delivery.agent.name &&
+            if (session.agent &&
+                session.agent.name === session.delivery.agent.name &&
                 session.agent.sessionRef === session.delivery.agent.sessionRef) {
                 session.agent.name = agent.name;
                 if (agent.sessionRef)
@@ -763,9 +883,40 @@ export class FileStateStore extends InMemoryStateStore {
         }));
     }
     async #loadFromDisk() {
+        return await this.#documentStore.read();
+    }
+    async #persist(document) {
+        await this.#documentStore.write(document);
+    }
+    async #withMutationLock(operation) {
+        return await this.#documentStore.runMutation(operation);
+    }
+    async #exclusive(operation) {
+        const result = this.#operation.then(operation, operation);
+        this.#operation = result.then(() => undefined, () => undefined);
+        return await result;
+    }
+}
+/** Node/file-backed state with the exact persistence and locking semantics used before the document seam. */
+export class FileStateStore extends DocumentStateStore {
+    constructor(options) {
+        super({
+            batchSize: options.batchSize,
+            agentQuestionDedupeLimit: options.agentQuestionDedupeLimit,
+            isProcessAlive: options.isProcessAlive,
+            documentStore: new FileWatchStateDocumentStore(options.watchStatePath),
+        });
+    }
+}
+class FileWatchStateDocumentStore {
+    #watchStatePath;
+    constructor(watchStatePath) {
+        this.#watchStatePath = watchStatePath;
+    }
+    async read() {
         try {
             const parsed = JSON.parse(await readFile(this.#watchStatePath, 'utf8'));
-            return parseDocument(parsed);
+            return parseWatchStateDocument(parsed);
         }
         catch (error) {
             if (!isMissingFileError(error))
@@ -773,7 +924,7 @@ export class FileStateStore extends InMemoryStateStore {
             return { version: 3, workspaces: {} };
         }
     }
-    async #persist(document) {
+    async write(document) {
         const temporaryPath = `${this.#watchStatePath}.${process.pid}.${randomUUID()}.tmp`;
         try {
             const handle = await open(temporaryPath, 'wx', 0o600);
@@ -791,7 +942,7 @@ export class FileStateStore extends InMemoryStateStore {
             await rm(temporaryPath, { force: true });
         }
     }
-    async #withMutationLock(operation) {
+    async runMutation(operation) {
         await mkdir(dirname(this.#watchStatePath), { recursive: true });
         const release = await lockfile.lock(this.#watchStatePath, {
             realpath: false,
@@ -812,92 +963,10 @@ export class FileStateStore extends InMemoryStateStore {
             await release();
         }
     }
-    async #exclusive(operation) {
-        const result = this.#operation.then(operation, operation);
-        this.#operation = result.then(() => undefined, () => undefined);
-        return await result;
+    async assertReady() {
+        await this.read();
     }
 }
-const parseDocument = (value) => {
-    if (!isRecord(value) || !isRecord(value.workspaces)) {
-        throw new Error('Factory GitHub watch state file is invalid');
-    }
-    if (value.version === 3) {
-        const workspaces = {};
-        for (const [workspaceId, rawWorkspace] of Object.entries(value.workspaces)) {
-            if (!isRecord(rawWorkspace))
-                throw new Error('Factory GitHub watch state file is invalid');
-            const watches = rawWorkspace.githubIssueCommentWatches;
-            const clarifications = rawWorkspace.waitingClarifications;
-            const babysitters = rawWorkspace.babysitterSessions;
-            const generations = rawWorkspace.babysitterGenerations;
-            const conversations = rawWorkspace.conversationSessions;
-            const lifecycles = rawWorkspace.dispatchLifecycles;
-            const discoverySweep = rawWorkspace.discoverySweep;
-            if (!isRecord(watches) ||
-                !isRecord(clarifications) ||
-                (babysitters !== undefined && !isRecord(babysitters)) ||
-                (generations !== undefined && !isRecord(generations)) ||
-                (conversations !== undefined && !isRecord(conversations)) ||
-                (lifecycles !== undefined && !isRecord(lifecycles)) ||
-                (discoverySweep !== undefined && !isRecord(discoverySweep))) {
-                throw new Error('Factory GitHub watch state file is invalid');
-            }
-            workspaces[workspaceId] = {
-                githubIssueCommentWatches: watches,
-                waitingClarifications: clarifications,
-                babysitterSessions: parseBabysitterSessions(babysitters ?? {}),
-                babysitterGenerations: parseBabysitterGenerations(generations ?? {}),
-                conversationSessions: parseConversationSessions(conversations ?? {}),
-                dispatchLifecycles: (lifecycles ?? {}),
-                discoverySweep: parseDiscoverySweepState(discoverySweep),
-            };
-        }
-        return { version: 3, workspaces };
-    }
-    if (value.version === 2) {
-        const workspaces = {};
-        for (const [workspaceId, rawWorkspace] of Object.entries(value.workspaces)) {
-            if (!isRecord(rawWorkspace))
-                throw new Error('Factory GitHub watch state file is invalid');
-            const watches = rawWorkspace.githubIssueCommentWatches;
-            const clarifications = rawWorkspace.waitingClarifications;
-            const babysitters = rawWorkspace.babysitterSessions;
-            if (!isRecord(watches) || !isRecord(clarifications) || (babysitters !== undefined && !isRecord(babysitters))) {
-                throw new Error('Factory GitHub watch state file is invalid');
-            }
-            workspaces[workspaceId] = {
-                githubIssueCommentWatches: watches,
-                waitingClarifications: clarifications,
-                babysitterSessions: parseBabysitterSessions(babysitters ?? {}),
-                babysitterGenerations: {},
-                conversationSessions: {},
-                dispatchLifecycles: {},
-                discoverySweep: emptyDiscoverySweepState(),
-            };
-        }
-        return { version: 3, workspaces };
-    }
-    if (value.version === 1) {
-        const workspaces = {};
-        for (const [workspaceId, watches] of Object.entries(value.workspaces)) {
-            if (!isRecord(watches)) {
-                throw new Error('Factory GitHub watch state file is invalid');
-            }
-            workspaces[workspaceId] = {
-                githubIssueCommentWatches: watches,
-                waitingClarifications: {},
-                babysitterSessions: {},
-                babysitterGenerations: {},
-                conversationSessions: {},
-                dispatchLifecycles: {},
-                discoverySweep: emptyDiscoverySweepState(),
-            };
-        }
-        return { version: 3, workspaces };
-    }
-    throw new Error('Factory GitHub watch state file is invalid');
-};
 const cloneWatch = (watch) => structuredClone(watch);
 const cloneClarification = (record) => structuredClone(record);
 const cloneBabysitterSession = (session) => structuredClone(session);
@@ -930,31 +999,6 @@ const processIsAlive = (pid) => {
         return error.code !== 'ESRCH';
     }
 };
-const emptyDiscoverySweepState = () => ({
-    consecutiveOverloads: 0,
-    backoffUntilMs: 0,
-    lastEpoch: 0,
-});
-const parseDiscoverySweepState = (value) => {
-    if (value === undefined)
-        return emptyDiscoverySweepState();
-    if (!isRecord(value))
-        throw new Error('Factory GitHub watch state file is invalid');
-    const checkpoint = value.checkpoint;
-    const lease = value.lease;
-    const lastEpoch = value.lastEpoch ?? (isRecord(lease) ? lease.epoch : 0);
-    if (!Number.isSafeInteger(value.consecutiveOverloads) || value.consecutiveOverloads < 0 ||
-        !Number.isSafeInteger(value.backoffUntilMs) ||
-        !Number.isSafeInteger(lastEpoch) || lastEpoch < 0 ||
-        (lease !== undefined && (!isRecord(lease) || typeof lease.owner !== 'string' ||
-            !Number.isSafeInteger(lease.epoch) || !Number.isSafeInteger(lease.leaseUntilMs))) ||
-        (checkpoint !== undefined && (!isRecord(checkpoint) || !isRecord(checkpoint.trees) ||
-            !Number.isSafeInteger(checkpoint.updatedAtMs) ||
-            (checkpoint.highWatermark !== undefined && typeof checkpoint.highWatermark !== 'string') ||
-            !Object.values(checkpoint.trees).every((paths) => Array.isArray(paths) && paths.every((path) => typeof path === 'string')))))
-        throw new Error('Factory GitHub watch state file is invalid');
-    return structuredClone({ ...value, lastEpoch });
-};
 const CONVERSATION_HISTORY_LIMIT = 50;
 const conversationHasMessage = (session, id) => session.processedMessageIds.includes(id) ||
     session.history.some((message) => message.id === id) ||
@@ -962,133 +1006,6 @@ const conversationHasMessage = (session, id) => session.processedMessageIds.incl
     Boolean(session.delivery?.messages.some((message) => message.id === id));
 const compareConversationMessages = (left, right) => left.receivedAtMs - right.receivedAtMs ||
     (left.providerSequence ?? left.id).localeCompare(right.providerSequence ?? right.id, undefined, { numeric: true });
-const parseConversationSessions = (value) => {
-    const sessions = {};
-    for (const [conversationId, candidate] of Object.entries(value)) {
-        if (!isRecord(candidate) || !isRecord(candidate.issue) || !isRecord(candidate.agent) || !isRecord(candidate.context)) {
-            throw new Error('Factory GitHub watch state file is invalid');
-        }
-        const issue = candidate.issue;
-        const agent = candidate.agent;
-        const delivery = candidate.delivery;
-        if (typeof issue.uuid !== 'string' || typeof issue.key !== 'string' || typeof issue.path !== 'string' ||
-            typeof candidate.provider !== 'string' || typeof candidate.externalId !== 'string' ||
-            !Object.values(candidate.context).every((value) => typeof value === 'string') ||
-            typeof agent.name !== 'string' || typeof agent.sessionRef !== 'string' ||
-            !validConversationMessages(candidate.history) || !validConversationMessages(candidate.pending) ||
-            (candidate.processedMessageIds !== undefined && !validConversationMessageIds(candidate.processedMessageIds)) ||
-            (delivery !== undefined && !validConversationDelivery(delivery) && !validLegacyConversationDelivery(delivery))) {
-            throw new Error('Factory GitHub watch state file is invalid');
-        }
-        const session = structuredClone(candidate);
-        if (delivery !== undefined && validLegacyConversationDelivery(delivery)) {
-            session.pending = [...structuredClone(delivery.messages), ...session.pending];
-            delete session.delivery;
-        }
-        session.processedMessageIds = candidate.processedMessageIds === undefined
-            ? [...new Set([
-                    ...session.history,
-                    ...session.pending,
-                    ...(session.delivery?.messages ?? []),
-                ].map((message) => message.id))]
-            : [...candidate.processedMessageIds];
-        sessions[conversationId] = session;
-    }
-    return sessions;
-};
-const validConversationMessages = (value) => Array.isArray(value) && value.every((message) => isRecord(message) &&
-    typeof message.id === 'string' && typeof message.text === 'string' &&
-    typeof message.receivedAtMs === 'number' &&
-    (message.providerSequence === undefined || typeof message.providerSequence === 'string') &&
-    (message.author === undefined || typeof message.author === 'string'));
-const validConversationDelivery = (value) => isRecord(value) &&
-    typeof value.claimId === 'string' && typeof value.owner === 'string' &&
-    typeof value.claimedAtMs === 'number' && typeof value.attempts === 'number' &&
-    validConversationMessages(value.messages) && isRecord(value.agent) &&
-    typeof value.agent.name === 'string' && typeof value.agent.sessionRef === 'string';
-const validLegacyConversationDelivery = (value) => isRecord(value) && value.claimId === undefined && value.agent === undefined &&
-    typeof value.owner === 'string' && typeof value.claimedAtMs === 'number' &&
-    typeof value.attempts === 'number' && validConversationMessages(value.messages);
-const validConversationMessageIds = (value) => Array.isArray(value) && value.every((id) => typeof id === 'string');
-const parseBabysitterSessions = (value) => {
-    const sessions = {};
-    for (const [key, candidate] of Object.entries(value)) {
-        if (!isRecord(candidate) || !isRecord(candidate.issue)) {
-            throw new Error('Factory GitHub watch state file is invalid');
-        }
-        const issue = candidate.issue;
-        if (typeof issue.uuid !== 'string' ||
-            typeof issue.key !== 'string' ||
-            typeof issue.path !== 'string' ||
-            typeof candidate.repo !== 'string' ||
-            !Number.isSafeInteger(candidate.prNumber) ||
-            candidate.prNumber < 1 ||
-            typeof candidate.agentName !== 'string' ||
-            (candidate.path !== undefined && typeof candidate.path !== 'string') ||
-            typeof candidate.critical !== 'boolean' ||
-            !Array.isArray(candidate.pendingKinds) ||
-            !candidate.pendingKinds.every((kind) => typeof kind === 'string') ||
-            (candidate.pendingDeliveryClaims !== undefined && (!Array.isArray(candidate.pendingDeliveryClaims) ||
-                !candidate.pendingDeliveryClaims.every((claim) => isRecord(claim) && typeof claim.deliveryId === 'string' && typeof claim.claimToken === 'string'))) ||
-            (candidate.resourceSubscription !== undefined && (!isRecord(candidate.resourceSubscription) ||
-                typeof candidate.resourceSubscription.subscriptionId !== 'string' ||
-                typeof candidate.resourceSubscription.provider !== 'string' ||
-                typeof candidate.resourceSubscription.resourceRef !== 'string' ||
-                typeof candidate.resourceSubscription.subscriberId !== 'string' ||
-                typeof candidate.resourceSubscription.ownerId !== 'string' ||
-                typeof candidate.resourceSubscription.expiresAt !== 'string' ||
-                (candidate.resourceSubscription.terminal !== undefined && typeof candidate.resourceSubscription.terminal !== 'boolean')))) {
-            throw new Error('Factory GitHub watch state file is invalid');
-        }
-        sessions[key] = {
-            issue: { uuid: issue.uuid, key: issue.key, path: issue.path },
-            repo: candidate.repo,
-            prNumber: candidate.prNumber,
-            agentName: candidate.agentName,
-            ...(candidate.path === undefined ? {} : { path: candidate.path }),
-            critical: candidate.critical,
-            pendingKinds: [...candidate.pendingKinds],
-            ...(candidate.resourceSubscription === undefined ? {} : {
-                resourceSubscription: {
-                    subscriptionId: candidate.resourceSubscription.subscriptionId,
-                    provider: candidate.resourceSubscription.provider,
-                    resourceRef: candidate.resourceSubscription.resourceRef,
-                    subscriberId: candidate.resourceSubscription.subscriberId,
-                    ownerId: candidate.resourceSubscription.ownerId,
-                    expiresAt: candidate.resourceSubscription.expiresAt,
-                    ...(candidate.resourceSubscription.terminal === undefined ? {} : { terminal: candidate.resourceSubscription.terminal }),
-                },
-            }),
-            ...(candidate.pendingDeliveryClaims === undefined ? {} : {
-                pendingDeliveryClaims: candidate.pendingDeliveryClaims.map((claim) => ({
-                    deliveryId: claim.deliveryId,
-                    claimToken: claim.claimToken,
-                })),
-            }),
-        };
-    }
-    return sessions;
-};
-const parseBabysitterGenerations = (value) => {
-    const generations = {};
-    for (const [key, candidate] of Object.entries(value)) {
-        if (!isRecord(candidate) ||
-            typeof candidate.generationId !== 'string' ||
-            typeof candidate.agentName !== 'string' ||
-            !Number.isSafeInteger(candidate.claimedAtMs) ||
-            !Number.isSafeInteger(candidate.leaseUntilMs) ||
-            (candidate.phase !== 'claimed' && candidate.phase !== 'completed'))
-            throw new Error('Factory GitHub watch state file is invalid');
-        generations[key] = {
-            generationId: candidate.generationId,
-            agentName: candidate.agentName,
-            claimedAtMs: candidate.claimedAtMs,
-            leaseUntilMs: candidate.leaseUntilMs,
-            phase: candidate.phase,
-        };
-    }
-    return generations;
-};
 const cloneLifecycle = (record) => structuredClone(record);
 const dispatchLifecycleLeaseMatches = (current, expected) => current === undefined
     ? expected === undefined
@@ -1112,6 +1029,7 @@ const dispatchLifecycleHandedOffToBabysitters = (lifecycle) => {
 };
 const emptyWorkspaceState = () => ({
     githubIssueCommentWatches: {},
+    slackThreadWatches: {},
     waitingClarifications: {},
     babysitterSessions: {},
     babysitterGenerations: {},
@@ -1120,6 +1038,7 @@ const emptyWorkspaceState = () => ({
     discoverySweep: emptyDiscoverySweepState(),
 });
 const workspaceIsEmpty = (workspace) => Object.keys(workspace.githubIssueCommentWatches).length === 0 &&
+    Object.keys(workspace.slackThreadWatches).length === 0 &&
     Object.keys(workspace.waitingClarifications).length === 0 &&
     Object.keys(workspace.babysitterSessions).length === 0 &&
     Object.keys(workspace.babysitterGenerations).length === 0 &&