devchain-cli 0.22.1 → 0.23.1

package/dist/server/modules/epic-time/services/epic-time.store.js

@@ -15,12 +15,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EpicTimeStore = void 0;
 const common_1 = require("@nestjs/common");
 const node_crypto_1 = require("node:crypto");
+const error_types_1 = require("../../../common/errors/error-types");
 const db_provider_1 = require("../../storage/db/db.provider");
 const sqlite_raw_1 = require("../../storage/db/sqlite-raw");
 const transaction_runner_1 = require("../../storage/db/transaction-runner");
 const TRACKING_STARTED_AT_KEY = 'epicTime.trackingStartedAt';
 const ACTIVITY_IDLE_TIMEOUT_KEY = 'activity.idleTimeoutMs';
 const DEFAULT_IDLE_TIMEOUT_MS = 30_000;
+const MILLIS_PER_MINUTE = 60_000;
+const STALE_SNAPSHOT_MESSAGE = 'The captured agent time snapshot changed. Refresh the buffered time and try again.';
+const RESOLVED_SCOPE_CTE = `
+  focal(focal_id) AS (
+    SELECT CAST(json_each.value AS TEXT) FROM json_each(?)
+  ),
+  route_chain(focal_id, epic_id) AS (
+    SELECT f.focal_id, e.id
+    FROM focal f
+    JOIN epics e ON e.id = f.focal_id AND e.parent_id IS NULL
+    UNION
+    SELECT rc.focal_id, source.id
+    FROM route_chain rc
+    JOIN epics target ON target.id = rc.epic_id
+    JOIN epics source
+      ON source.parent_id IS NULL AND source.project_id = target.project_id
+    JOIN epic_relations rel
+      ON rel.type = 'related'
+     AND (
+       (rel.left_epic_id = source.id AND rel.right_epic_id = target.id
+          AND rel.direction = 'left_to_right')
+       OR (rel.left_epic_id = target.id AND rel.right_epic_id = source.id
+          AND rel.direction = 'right_to_left')
+     )
+    WHERE NOT EXISTS (
+      SELECT 1 FROM external_task_links link WHERE link.epic_id = source.id
+    )
+  )`;
+function buildBufferSnapshotToken(projectId, agentId, rows) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify({
+        agentId,
+        projectId,
+        rows: rows.map((row) => ({
+            closedAt: row.closed_at,
+            durationMs: row.duration_ms,
+            id: row.id,
+            lastActivityAt: row.last_activity_at,
+            startedAt: row.started_at,
+            updatedAt: row.updated_at,
+        })),
+    }))
+        .digest('hex');
+}
 let EpicTimeStore = class EpicTimeStore {
     rawClient;
     transactionRunner;
@@ -51,6 +96,12 @@ let EpicTimeStore = class EpicTimeStore {
             };
         });
     }
+    readActivationSettings() {
+        return {
+            trackingStartedAt: this.readSetting(TRACKING_STARTED_AT_KEY),
+            idleTimeoutMs: this.readIdleTimeoutMs(),
+        };
+    }
     listReconciliationSessionIds(trackingStartedAt) {
         return this.rawClient
             .prepare(`SELECT session_id
@@ -70,130 +121,194 @@ let EpicTimeStore = class EpicTimeStore {
             .all(trackingStartedAt).map((row) => row.session_id);
     }
     async reconcileSession(sessionId, trackingStartedAt, idleTimeoutMs, now = new Date(), options = {}) {
+        return this.transactionRunner.runImmediateQueued(() => this.reconcileSessionCore(sessionId, trackingStartedAt, idleTimeoutMs, now, options));
+    }
+    reconcileSessionCore(sessionId, trackingStartedAt, idleTimeoutMs, now, options) {
         const nowIso = now.toISOString();
-        return this.transactionRunner.runImmediateQueued(() => {
-            let openSegment = this.loadOpenSegment(sessionId);
-            const session = this.loadSession(sessionId);
-            if (!session) {
-                if (openSegment) {
-                    this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
-                    return {
-                        sessionId,
-                        action: 'closed',
-                        watermark: null,
-                        segmentId: openSegment.id,
-                    };
-                }
-                return { sessionId, action: 'noop', watermark: null, segmentId: null };
-            }
-            const watermark = this.loadWatermark(sessionId);
-            const activityAt = session.last_activity_at;
-            const hasNewActivity = activityAt !== null &&
-                this.isAfter(activityAt, trackingStartedAt) &&
-                (!watermark || this.isAfter(activityAt, watermark.last_activity_at));
-            if (!session.agent_id || !session.project_id || !session.agent_name) {
-                if (openSegment) {
-                    this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
-                }
-                let action = 'noop';
-                if (hasNewActivity) {
-                    action = 'discarded';
-                }
-                else if (openSegment) {
-                    action = 'closed';
-                }
-                const watermarkProjectId = session.project_id ?? session.epic_project_id ?? openSegment?.project_id;
-                if (hasNewActivity && activityAt && watermarkProjectId) {
-                    this.upsertWatermark(session.id, watermarkProjectId, activityAt, nowIso);
-                }
+        let openSegment = this.loadOpenSegment(sessionId);
+        const session = this.loadSession(sessionId);
+        if (!session) {
+            if (openSegment) {
+                this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
                 return {
                     sessionId,
-                    action,
-                    watermark: hasNewActivity ? activityAt : (watermark?.last_activity_at ?? null),
-                    segmentId: openSegment?.id ?? null,
+                    action: 'closed',
+                    watermark: null,
+                    segmentId: openSegment.id,
                 };
             }
+            return { sessionId, action: 'noop', watermark: null, segmentId: null };
+        }
+        const watermark = this.loadWatermark(sessionId);
+        const activityAt = session.last_activity_at;
+        const hasNewActivity = activityAt !== null &&
+            this.isAfter(activityAt, trackingStartedAt) &&
+            (!watermark || this.isAfter(activityAt, watermark.last_activity_at));
+        if (!session.agent_id || !session.project_id || !session.agent_name) {
+            if (openSegment) {
+                this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
+            }
             let action = 'noop';
-            let segmentId = openSegment?.id ?? null;
-            if (hasNewActivity && activityAt) {
-                const hadOpenSegment = openSegment !== null;
-                const epicId = this.resolveAttributionEpic(session);
-                const priorActivityAt = openSegment?.last_activity_at ?? watermark?.last_activity_at ?? null;
-                const busyStart = session.activity_state === 'busy' && session.busy_since ? session.busy_since : activityAt;
-                const continuityStart = priorActivityAt ?? busyStart;
-                const continuityGapMs = this.elapsedMs(continuityStart, activityAt);
-                const continuous = continuityGapMs >= 0 && continuityGapMs <= idleTimeoutMs;
-                const sameSegment = openSegment !== null &&
-                    openSegment.project_id === session.project_id &&
-                    openSegment.agent_id_snapshot === session.agent_id &&
-                    openSegment.epic_id === epicId &&
-                    continuous;
-                if (sameSegment && openSegment) {
-                    const deltaMs = this.elapsedMs(openSegment.last_activity_at, activityAt);
-                    this.rawClient
-                        .prepare(`UPDATE epic_time_segments
-               SET last_activity_at = ?, duration_ms = duration_ms + ?, updated_at = ?
-               WHERE id = ? AND closed_at IS NULL`)
-                        .run(activityAt, deltaMs, nowIso, openSegment.id);
-                    action = 'advanced';
-                }
-                else {
-                    if (openSegment) {
-                        this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
-                        openSegment = null;
-                    }
-                    const lowerBound = this.latestTimestamp([
-                        trackingStartedAt,
-                        session.started_at,
-                        watermark?.last_activity_at ?? null,
-                    ]);
-                    const busyStartProvesNewWindow = !watermark || this.isAfter(busyStart, watermark.last_activity_at);
-                    const startedAt = continuous && (hadOpenSegment || busyStartProvesNewWindow)
-                        ? this.latestTimestamp([busyStart, lowerBound])
-                        : activityAt;
-                    const durationMs = Math.max(0, this.elapsedMs(startedAt, activityAt));
-                    segmentId = (0, node_crypto_1.randomUUID)();
-                    this.rawClient
-                        .prepare(`INSERT INTO epic_time_segments
-                 (id, project_id, epic_id, session_id_snapshot, agent_id_snapshot,
-                  agent_name_snapshot, started_at, last_activity_at, closed_at,
-                  duration_ms, created_at, updated_at)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)`)
-                        .run(segmentId, session.project_id, epicId, session.id, session.agent_id, session.agent_name, startedAt, activityAt, durationMs, nowIso, nowIso);
-                    action = 'created';
-                    if (epicId === null) {
-                        const pendingClaim = this.applyPendingBufferClaims(session.project_id, session.agent_id, nowIso);
-                        if (pendingClaim.discardedSegmentIds.has(segmentId)) {
-                            action = 'discarded';
-                            segmentId = null;
-                        }
-                    }
-                }
-                this.upsertWatermark(session.id, session.project_id, activityAt, nowIso);
-                openSegment = this.loadOpenSegment(sessionId);
+            if (hasNewActivity) {
+                action = 'discarded';
             }
-            if (openSegment &&
-                (options.forceCloseOpenSegment ||
-                    this.shouldClose(session, openSegment.last_activity_at, idleTimeoutMs, now))) {
-                this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
-                if (action === 'created') {
-                    action = 'created_closed';
-                }
-                else if (action === 'advanced') {
-                    action = 'advanced_closed';
-                }
-                else {
-                    action = 'closed';
-                }
-                segmentId = openSegment.id;
+            else if (openSegment) {
+                action = 'closed';
+            }
+            const watermarkProjectId = session.project_id ?? session.epic_project_id ?? openSegment?.project_id;
+            if (hasNewActivity && activityAt && watermarkProjectId) {
+                this.upsertWatermark(session.id, watermarkProjectId, activityAt, nowIso);
             }
             return {
                 sessionId,
                 action,
                 watermark: hasNewActivity ? activityAt : (watermark?.last_activity_at ?? null),
-                segmentId,
+                segmentId: openSegment?.id ?? null,
             };
-        });
+        }
+        let action = 'noop';
+        let segmentId = openSegment?.id ?? null;
+        if (hasNewActivity && activityAt) {
+            const hadOpenSegment = openSegment !== null;
+            const epicId = this.resolveAttributionEpic(session);
+            const eligibleTeam = epicId === null ? this.resolveEligibleTeam(session) : null;
+            const openTeamBatch = eligibleTeam
+                ? this.loadOpenTeamBatch(session.project_id, eligibleTeam.team_id)
+                : null;
+            const priorActivityAt = openSegment?.last_activity_at ?? watermark?.last_activity_at ?? null;
+            const busyStart = session.activity_state === 'busy' && session.busy_since ? session.busy_since : activityAt;
+            const continuityStart = priorActivityAt ?? busyStart;
+            const continuityGapMs = this.elapsedMs(continuityStart, activityAt);
+            const continuous = continuityGapMs >= 0 && continuityGapMs <= idleTimeoutMs;
+            const sameSegment = openSegment !== null &&
+                openSegment.project_id === session.project_id &&
+                openSegment.agent_id_snapshot === session.agent_id &&
+                openSegment.epic_id === epicId &&
+                (eligibleTeam
+                    ? openTeamBatch !== null && openSegment.team_batch_id === openTeamBatch.id
+                    : openSegment.team_batch_id === null) &&
+                continuous;
+            if (sameSegment && openSegment) {
+                const deltaMs = this.elapsedMs(openSegment.last_activity_at, activityAt);
+                this.rawClient
+                    .prepare(`UPDATE epic_time_segments
+               SET last_activity_at = ?, duration_ms = duration_ms + ?, updated_at = ?
+               WHERE id = ? AND closed_at IS NULL`)
+                    .run(activityAt, deltaMs, nowIso, openSegment.id);
+                action = 'advanced';
+            }
+            else {
+                if (openSegment) {
+                    this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
+                    openSegment = null;
+                }
+                const lowerBound = this.latestTimestamp([
+                    trackingStartedAt,
+                    session.started_at,
+                    watermark?.last_activity_at ?? null,
+                ]);
+                const busyStartProvesNewWindow = !watermark || this.isAfter(busyStart, watermark.last_activity_at);
+                const startedAt = continuous && (hadOpenSegment || busyStartProvesNewWindow)
+                    ? this.latestTimestamp([busyStart, lowerBound])
+                    : activityAt;
+                const durationMs = Math.max(0, this.elapsedMs(startedAt, activityAt));
+                const teamBatch = eligibleTeam
+                    ? (openTeamBatch ??
+                        this.createOrLoadOpenTeamBatch(session.project_id, eligibleTeam, startedAt, nowIso))
+                    : null;
+                segmentId = (0, node_crypto_1.randomUUID)();
+                this.rawClient
+                    .prepare(`INSERT INTO epic_time_segments
+                 (id, project_id, epic_id, team_batch_id, attribution_source,
+                  team_id_snapshot, team_name_snapshot, session_id_snapshot,
+                  agent_id_snapshot, agent_name_snapshot, started_at, last_activity_at,
+                  closed_at, duration_ms, created_at, updated_at)
+               VALUES (?, ?, ?, ?, 'direct', ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)`)
+                    .run(segmentId, session.project_id, epicId, teamBatch?.id ?? null, eligibleTeam?.team_id ?? null, eligibleTeam?.team_name ?? null, session.id, session.agent_id, session.agent_name, startedAt, activityAt, durationMs, nowIso, nowIso);
+                action = 'created';
+                if (epicId === null) {
+                    const pendingClaim = this.applyPendingBufferClaims(session.project_id, session.agent_id, nowIso);
+                    if (pendingClaim.discardedSegmentIds.has(segmentId)) {
+                        action = 'discarded';
+                        segmentId = null;
+                    }
+                }
+            }
+            this.upsertWatermark(session.id, session.project_id, activityAt, nowIso);
+            openSegment = this.loadOpenSegment(sessionId);
+        }
+        if (openSegment &&
+            (options.forceCloseOpenSegment ||
+                this.shouldClose(session, openSegment.last_activity_at, idleTimeoutMs, now))) {
+            this.closeSegment(openSegment.id, openSegment.last_activity_at, nowIso);
+            if (action === 'created') {
+                action = 'created_closed';
+            }
+            else if (action === 'advanced') {
+                action = 'advanced_closed';
+            }
+            else {
+                action = 'closed';
+            }
+            segmentId = openSegment.id;
+        }
+        return {
+            sessionId,
+            action,
+            watermark: hasNewActivity ? activityAt : (watermark?.last_activity_at ?? null),
+            segmentId,
+        };
+    }
+    async processTeamBatches(deliveryKey, idleTimeoutMs, now = new Date()) {
+        return this.transactionRunner.runImmediateQueued(() => this.processTeamBatchesCore(deliveryKey, idleTimeoutMs, now));
+    }
+    processTeamBatchesCore(deliveryKey, idleTimeoutMs, now) {
+        const nowIso = now.toISOString();
+        const activeAfter = new Date(now.getTime() - idleTimeoutMs).toISOString();
+        let sealedBatches = 0;
+        let finalizedBatches = 0;
+        let cancelledBatches = 0;
+        const openBatches = this.loadTeamBatches(false);
+        for (const batch of openBatches) {
+            if (this.hasActiveEligibleMember(batch, activeAfter)) {
+                continue;
+            }
+            this.rawClient
+                .prepare(`UPDATE epic_time_segments
+             SET closed_at = COALESCE(closed_at, last_activity_at), updated_at = ?
+             WHERE team_batch_id = ?`)
+                .run(nowIso, batch.id);
+            this.rawClient
+                .prepare(`UPDATE epic_time_team_batches
+             SET sealed_at = ?, updated_at = ?
+             WHERE id = ? AND sealed_at IS NULL`)
+                .run(nowIso, nowIso, batch.id);
+            this.rawClient
+                .prepare(`INSERT OR IGNORE INTO epic_time_team_batch_event_barriers
+               (team_batch_id, committed_event_id, created_at)
+             SELECT ?, eh.event_id, ?
+             FROM event_handlers eh
+             INNER JOIN events e ON e.id = eh.event_id
+             WHERE eh.delivery_key = ?
+               AND eh.status IN ('pending', 'running', 'retry')
+               AND e.published_at <= ?`)
+                .run(batch.id, nowIso, deliveryKey, nowIso);
+            sealedBatches += 1;
+        }
+        const sealed = this.loadTeamBatches(true);
+        for (const batch of sealed) {
+            if (this.batchHasPendingBarrier(batch.id, deliveryKey)) {
+                continue;
+            }
+            if (!this.isTeamBatchIdentityCurrent(batch)) {
+                this.cancelTeamBatch(batch.id, nowIso);
+                cancelledBatches += 1;
+                continue;
+            }
+            this.finalizeTeamBatch(batch, nowIso);
+            finalizedBatches += 1;
+        }
+        return { sealedBatches, finalizedBatches, cancelledBatches };
     }
     async recordTaskTouch(touch, now = new Date()) {
         const nowIso = now.toISOString();
@@ -223,6 +338,150 @@ let EpicTimeStore = class EpicTimeStore {
             };
         });
     }
+    listAgentTimeBuffers(projectId) {
+        const rows = this.listEligibleBufferRows(projectId, null);
+        if (rows.length === 0) {
+            return { capturedAt: null, items: [] };
+        }
+        let capturedAt = rows[0].updated_at;
+        let capturedAtMs = this.timestampMs(capturedAt);
+        const rowsByAgent = new Map();
+        for (const row of rows) {
+            const updatedAtMs = this.timestampMs(row.updated_at);
+            if (updatedAtMs > capturedAtMs) {
+                capturedAt = row.updated_at;
+                capturedAtMs = updatedAtMs;
+            }
+            const agentRows = rowsByAgent.get(row.agent_id_snapshot) ?? [];
+            agentRows.push(row);
+            rowsByAgent.set(row.agent_id_snapshot, agentRows);
+        }
+        const items = [];
+        for (const [agentId, agentRows] of rowsByAgent) {
+            const durationMs = agentRows.reduce((total, row) => total + row.duration_ms, 0);
+            let oldest = agentRows[0].last_activity_at;
+            let newest = agentRows[0].last_activity_at;
+            for (const row of agentRows.slice(1)) {
+                if (this.timestampMs(row.last_activity_at) < this.timestampMs(oldest)) {
+                    oldest = row.last_activity_at;
+                }
+                if (this.timestampMs(row.last_activity_at) > this.timestampMs(newest)) {
+                    newest = row.last_activity_at;
+                }
+            }
+            items.push({
+                agentId,
+                snapshotToken: buildBufferSnapshotToken(projectId, agentId, agentRows),
+                minutes: Math.floor(durationMs / MILLIS_PER_MINUTE),
+                durationMs,
+                segmentCount: agentRows.length,
+                oldestActivityAt: oldest,
+                newestActivityAt: newest,
+            });
+        }
+        items.sort((left, right) => left.agentId.localeCompare(right.agentId));
+        return { capturedAt, items };
+    }
+    async assignAgentTimeBuffer(input, now = new Date()) {
+        const nowIso = now.toISOString();
+        return this.transactionRunner.runImmediateQueued(() => {
+            const project = this.rawClient
+                .prepare(`SELECT workspace_id FROM projects WHERE id = ?`)
+                .get(input.projectId);
+            if (!project) {
+                throw new error_types_1.NotFoundError('Project', input.projectId);
+            }
+            const agent = this.rawClient
+                .prepare(`SELECT id FROM agents WHERE id = ? AND project_id = ?`)
+                .get(input.agentId, input.projectId);
+            if (!agent) {
+                throw new error_types_1.NotFoundError('Agent', input.agentId);
+            }
+            const epic = this.rawClient
+                .prepare(`SELECT id FROM epics WHERE id = ? AND project_id = ?`)
+                .get(input.targetEpicId, input.projectId);
+            if (!epic) {
+                throw new error_types_1.NotFoundError('Epic', input.targetEpicId);
+            }
+            const rows = this.requireCapturedBufferRows(input);
+            const assignRow = this.rawClient.prepare(`UPDATE epic_time_segments
+         SET epic_id = ?, updated_at = ?
+         WHERE id = ?
+           AND epic_id IS NULL
+           AND team_batch_id IS NULL
+           AND closed_at IS NOT NULL`);
+            for (const row of rows) {
+                if (assignRow.run(input.targetEpicId, nowIso, row.id).changes !== 1) {
+                    throw new error_types_1.ConflictError(STALE_SNAPSHOT_MESSAGE);
+                }
+            }
+            return { workspaceId: project.workspace_id };
+        });
+    }
+    async resetAgentTimeBuffer(input) {
+        return this.transactionRunner.runImmediateQueued(() => {
+            const project = this.rawClient
+                .prepare(`SELECT workspace_id FROM projects WHERE id = ?`)
+                .get(input.projectId);
+            if (!project) {
+                throw new error_types_1.NotFoundError('Project', input.projectId);
+            }
+            const agent = this.rawClient
+                .prepare(`SELECT id FROM agents WHERE id = ? AND project_id = ?`)
+                .get(input.agentId, input.projectId);
+            if (!agent) {
+                throw new error_types_1.NotFoundError('Agent', input.agentId);
+            }
+            const rows = this.requireCapturedBufferRows(input);
+            const deleteRow = this.rawClient.prepare(`DELETE FROM epic_time_segments
+         WHERE id = ?
+           AND epic_id IS NULL
+           AND team_batch_id IS NULL
+           AND closed_at IS NOT NULL
+           AND duration_ms > 0`);
+            for (const row of rows) {
+                if (deleteRow.run(row.id).changes !== 1) {
+                    throw new error_types_1.ConflictError(STALE_SNAPSHOT_MESSAGE);
+                }
+            }
+            return { workspaceId: project.workspace_id };
+        });
+    }
+    runTerminationResetSync(input) {
+        const now = input.now;
+        this.reconcileSessionCore(input.sessionId, input.trackingStartedAt, input.idleTimeoutMs, now, {});
+        this.processTeamBatchesCore(input.deliveryKey, input.idleTimeoutMs, now);
+        if (!input.agentId) {
+            return { workspaceId: null, deletedSegments: 0 };
+        }
+        const deleted = this.rawClient
+            .prepare(`DELETE FROM epic_time_segments
+         WHERE id IN (
+           SELECT seg.id
+           FROM epic_time_segments seg
+           INNER JOIN agents a
+             ON a.id = seg.agent_id_snapshot AND a.project_id = seg.project_id
+           WHERE seg.agent_id_snapshot = ?
+             AND seg.epic_id IS NULL
+             AND seg.team_batch_id IS NULL
+             AND seg.closed_at IS NOT NULL
+             AND seg.duration_ms > 0
+         )`)
+            .run(input.agentId);
+        if (deleted.changes === 0) {
+            return { workspaceId: null, deletedSegments: 0 };
+        }
+        const agentProject = this.rawClient
+            .prepare(`SELECT p.workspace_id AS workspace_id
+         FROM agents a
+         INNER JOIN projects p ON p.id = a.project_id
+         WHERE a.id = ?`)
+            .get(input.agentId);
+        return {
+            workspaceId: agentProject?.workspace_id ?? null,
+            deletedSegments: deleted.changes,
+        };
+    }
     getEpicTimeScope(epicId) {
         const row = this.rawClient
             .prepare(`SELECT id, parent_id FROM epics WHERE id = ?`)
@@ -238,40 +497,274 @@ let EpicTimeStore = class EpicTimeStore {
             .prepare(`SELECT id, parent_id FROM epics WHERE id IN (${placeholders})`)
             .all(...epicIds).map((row) => ({ id: row.id, parentId: row.parent_id }));
     }
-    listClosedSegmentsForEpic(epicId, includeDirectChildren) {
-        const rows = this.rawClient
-            .prepare(`SELECT s.id, scoped.id AS epic_id, scoped.title AS epic_title,
-                s.agent_id_snapshot, s.agent_name_snapshot,
-                s.duration_ms, s.last_activity_at, s.updated_at
-         FROM epic_time_segments s
-         INNER JOIN epics scoped ON scoped.id = s.epic_id AND scoped.project_id = s.project_id
-         WHERE s.closed_at IS NOT NULL
-           AND (scoped.id = ? OR (? = 1 AND scoped.parent_id = ?))
-         ORDER BY s.last_activity_at, s.id`)
-            .all(epicId, includeDirectChildren ? 1 : 0, epicId);
-        return rows.map((row) => this.mapSummarySegment(row, null, row.epic_id === epicId));
-    }
-    listClosedSegmentsForRoots(rootEpicIds) {
-        if (rootEpicIds.length === 0) {
-            return [];
+    listResolvedScope(focalEpicIds) {
+        if (focalEpicIds.length === 0) {
+            return { segments: [], routedRootIdsByFocal: new Map() };
         }
-        const placeholders = rootEpicIds.map(() => '?').join(', ');
         const rows = this.rawClient
-            .prepare(`SELECT roots.id AS root_epic_id, s.id, scoped.id AS epic_id,
-                scoped.title AS epic_title, s.agent_id_snapshot,
-                s.agent_name_snapshot, s.duration_ms, s.last_activity_at, s.updated_at
-         FROM epics roots
-         INNER JOIN epics scoped
-           ON (scoped.id = roots.id OR scoped.parent_id = roots.id)
-          AND scoped.project_id = roots.project_id
-         INNER JOIN epic_time_segments s
-           ON s.project_id = roots.project_id
-          AND s.epic_id = scoped.id
-          AND s.closed_at IS NOT NULL
-         WHERE roots.id IN (${placeholders})
-         ORDER BY roots.id, s.last_activity_at, s.id`)
-            .all(...rootEpicIds);
-        return rows.map((row) => this.mapSummarySegment(row, row.root_epic_id, row.epic_id === row.root_epic_id));
+            .prepare(`WITH RECURSIVE
+         ${RESOLVED_SCOPE_CTE},
+         scope(focal_id, epic_id, is_direct, group_epic_id) AS (
+           SELECT f.focal_id, e.id, 1, f.focal_id
+           FROM focal f
+           JOIN epics e ON e.id = f.focal_id
+           UNION
+           SELECT f.focal_id, child.id, 0, f.focal_id
+           FROM focal f
+           JOIN epics e ON e.id = f.focal_id AND e.parent_id IS NULL
+           JOIN epics child ON child.parent_id = e.id AND child.project_id = e.project_id
+           UNION
+           SELECT rc.focal_id, rc.epic_id, 0, rc.epic_id
+           FROM route_chain rc
+           WHERE rc.epic_id <> rc.focal_id
+           UNION
+           SELECT rc.focal_id, child.id, 0, rc.epic_id
+           FROM route_chain rc
+           JOIN epics routed ON routed.id = rc.epic_id
+           JOIN epics child ON child.parent_id = routed.id AND child.project_id = routed.project_id
+           WHERE rc.epic_id <> rc.focal_id
+             AND NOT EXISTS (
+               SELECT 1 FROM external_task_links link WHERE link.epic_id = child.id
+             )
+         )
+         SELECT DISTINCT scope.focal_id AS root_epic_id,
+                seg.id AS segment_id,
+                scoped.id AS epic_id, scoped.title AS epic_title,
+                seg.agent_id_snapshot, seg.agent_name_snapshot, seg.attribution_source,
+                seg.team_id_snapshot, seg.team_name_snapshot,
+                seg.duration_ms, seg.last_activity_at, seg.updated_at,
+                scope.is_direct AS is_direct,
+                scope.group_epic_id AS group_epic_id,
+                group_epic.title AS group_epic_title,
+                NULL AS routed_epic_id
+         FROM scope
+         JOIN epics scoped ON scoped.id = scope.epic_id
+         LEFT JOIN epics group_epic ON group_epic.id = scope.group_epic_id
+         JOIN epic_time_segments seg
+           ON seg.epic_id = scoped.id
+          AND seg.project_id = scoped.project_id
+          AND seg.closed_at IS NOT NULL
+         UNION ALL
+         SELECT DISTINCT rc.focal_id, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                NULL, NULL, NULL, NULL, NULL, NULL, NULL, rc.epic_id
+         FROM route_chain rc
+         WHERE rc.epic_id <> rc.focal_id
+         ORDER BY root_epic_id, last_activity_at, segment_id`)
+            .all(JSON.stringify(focalEpicIds));
+        const segments = [];
+        const routedRootIdsByFocal = new Map();
+        for (const row of rows) {
+            if (row.routed_epic_id !== null) {
+                const routed = routedRootIdsByFocal.get(row.root_epic_id) ?? [];
+                routed.push(row.routed_epic_id);
+                routedRootIdsByFocal.set(row.root_epic_id, routed);
+                continue;
+            }
+            segments.push(this.mapSummarySegment({
+                id: row.segment_id,
+                epic_id: row.epic_id,
+                epic_title: row.epic_title,
+                agent_id_snapshot: row.agent_id_snapshot,
+                agent_name_snapshot: row.agent_name_snapshot,
+                attribution_source: row.attribution_source,
+                team_id_snapshot: row.team_id_snapshot,
+                team_name_snapshot: row.team_name_snapshot,
+                duration_ms: row.duration_ms,
+                last_activity_at: row.last_activity_at,
+                updated_at: row.updated_at,
+            }, row.root_epic_id, row.is_direct === 1, row.group_epic_id, row.group_epic_title));
+        }
+        for (const routed of routedRootIdsByFocal.values()) {
+            routed.sort();
+        }
+        for (const focalId of focalEpicIds) {
+            if (!routedRootIdsByFocal.has(focalId)) {
+                routedRootIdsByFocal.set(focalId, []);
+            }
+        }
+        return { segments, routedRootIdsByFocal };
+    }
+    resolveEligibleTeam(session) {
+        if (!session.agent_id || !session.project_id) {
+            return null;
+        }
+        return (this.rawClient
+            .prepare(`SELECT t.id AS team_id, t.name AS team_name,
+                  lead.id AS lead_agent_id, lead.name AS lead_agent_name
+           FROM team_members tm
+           INNER JOIN teams t ON t.id = tm.team_id AND t.project_id = ?
+           INNER JOIN agents lead
+             ON lead.id = t.team_lead_agent_id AND lead.project_id = t.project_id
+           WHERE tm.agent_id = ?
+             AND t.team_lead_agent_id <> tm.agent_id
+             AND (
+               SELECT COUNT(*)
+               FROM team_members memberships
+               INNER JOIN teams member_teams
+                 ON member_teams.id = memberships.team_id
+                AND member_teams.project_id = ?
+               WHERE memberships.agent_id = tm.agent_id
+             ) = 1
+           LIMIT 1`)
+            .get(session.project_id, session.agent_id, session.project_id) ?? null);
+    }
+    loadOpenTeamBatch(projectId, teamId) {
+        return (this.rawClient
+            .prepare(`SELECT id, project_id, team_id_snapshot, team_name_snapshot,
+                  lead_agent_id_snapshot, lead_agent_name_snapshot, started_at, sealed_at
+           FROM epic_time_team_batches
+           WHERE project_id = ? AND team_id_snapshot = ? AND sealed_at IS NULL`)
+            .get(projectId, teamId) ?? null);
+    }
+    createOrLoadOpenTeamBatch(projectId, team, startedAt, nowIso) {
+        this.rawClient
+            .prepare(`INSERT INTO epic_time_team_batches
+           (id, project_id, team_id_snapshot, team_name_snapshot,
+            lead_agent_id_snapshot, lead_agent_name_snapshot, started_at,
+            sealed_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
+         ON CONFLICT DO NOTHING`)
+            .run((0, node_crypto_1.randomUUID)(), projectId, team.team_id, team.team_name, team.lead_agent_id, team.lead_agent_name, startedAt, nowIso, nowIso);
+        const batch = this.loadOpenTeamBatch(projectId, team.team_id);
+        if (!batch) {
+            throw new Error('Unable to create or load the open Epic-time team batch.');
+        }
+        return batch;
+    }
+    loadTeamBatches(sealed) {
+        return this.rawClient
+            .prepare(`SELECT id, project_id, team_id_snapshot, team_name_snapshot,
+                lead_agent_id_snapshot, lead_agent_name_snapshot, started_at, sealed_at
+         FROM epic_time_team_batches
+         WHERE sealed_at IS ${sealed ? 'NOT NULL' : 'NULL'}
+         ORDER BY started_at, id`)
+            .all();
+    }
+    hasActiveEligibleMember(batch, activeAfter) {
+        return Boolean(this.rawClient
+            .prepare(`SELECT 1
+           FROM sessions s
+           INNER JOIN agents a
+             ON a.id = s.agent_id AND a.project_id = ?
+           INNER JOIN team_members tm
+             ON tm.agent_id = a.id AND tm.team_id = ?
+           INNER JOIN teams t
+             ON t.id = tm.team_id
+            AND t.project_id = ?
+            AND t.team_lead_agent_id = ?
+           INNER JOIN agents lead
+             ON lead.id = t.team_lead_agent_id AND lead.project_id = t.project_id
+           WHERE s.status = 'running'
+             AND (s.activity_state IS NULL OR s.activity_state <> 'idle')
+             AND s.last_activity_at > ?
+             AND a.id <> t.team_lead_agent_id
+             AND (
+               SELECT COUNT(*)
+               FROM team_members memberships
+               INNER JOIN teams member_teams
+                 ON member_teams.id = memberships.team_id
+                AND member_teams.project_id = ?
+               WHERE memberships.agent_id = a.id
+             ) = 1
+             AND NOT EXISTS (
+               SELECT 1 FROM epics bound
+               WHERE bound.id = s.epic_id AND bound.project_id = ?
+             )
+             AND NOT EXISTS (
+               SELECT 1 FROM epics assigned
+               WHERE assigned.project_id = ? AND assigned.agent_id = a.id
+             )
+           LIMIT 1`)
+            .get(batch.project_id, batch.team_id_snapshot, batch.project_id, batch.lead_agent_id_snapshot, activeAfter, batch.project_id, batch.project_id, batch.project_id));
+    }
+    batchHasPendingBarrier(batchId, deliveryKey) {
+        return Boolean(this.rawClient
+            .prepare(`SELECT 1
+           FROM epic_time_team_batch_event_barriers barrier
+           INNER JOIN event_handlers delivery
+             ON delivery.event_id = barrier.committed_event_id
+            AND delivery.delivery_key = ?
+           WHERE barrier.team_batch_id = ?
+             AND delivery.status IN ('pending', 'running', 'retry')
+           LIMIT 1`)
+            .get(deliveryKey, batchId));
+    }
+    isTeamBatchIdentityCurrent(batch) {
+        const teamStillMatches = Boolean(this.rawClient
+            .prepare(`SELECT 1
+           FROM teams t
+           INNER JOIN agents lead
+             ON lead.id = t.team_lead_agent_id AND lead.project_id = t.project_id
+           WHERE t.id = ? AND t.project_id = ? AND t.team_lead_agent_id = ?`)
+            .get(batch.team_id_snapshot, batch.project_id, batch.lead_agent_id_snapshot));
+        if (!teamStillMatches) {
+            return false;
+        }
+        return !this.rawClient
+            .prepare(`SELECT 1
+         FROM epic_time_segments segment
+         LEFT JOIN agents original
+           ON original.id = segment.agent_id_snapshot AND original.project_id = segment.project_id
+         WHERE segment.team_batch_id = ?
+           AND segment.epic_id IS NULL
+           AND (
+             original.id IS NULL
+             OR NOT EXISTS (
+               SELECT 1 FROM team_members exact_membership
+               WHERE exact_membership.team_id = ?
+                 AND exact_membership.agent_id = segment.agent_id_snapshot
+             )
+             OR (
+               SELECT COUNT(*)
+               FROM team_members memberships
+               INNER JOIN teams member_teams
+                 ON member_teams.id = memberships.team_id
+                AND member_teams.project_id = segment.project_id
+               WHERE memberships.agent_id = segment.agent_id_snapshot
+             ) <> 1
+           )
+         LIMIT 1`)
+            .get(batch.id, batch.team_id_snapshot);
+    }
+    cancelTeamBatch(batchId, nowIso) {
+        this.rawClient
+            .prepare(`UPDATE epic_time_segments
+         SET team_batch_id = NULL, attribution_source = 'direct',
+             team_id_snapshot = NULL, team_name_snapshot = NULL, updated_at = ?
+         WHERE team_batch_id = ? AND epic_id IS NULL`)
+            .run(nowIso, batchId);
+        this.rawClient.prepare(`DELETE FROM epic_time_team_batches WHERE id = ?`).run(batchId);
+    }
+    finalizeTeamBatch(batch, nowIso) {
+        const winner = this.rawClient
+            .prepare(`SELECT agent_id_snapshot, SUM(duration_ms) AS duration_ms,
+                MIN(started_at) AS earliest_started_at
+         FROM epic_time_segments
+         WHERE team_batch_id = ? AND epic_id IS NULL
+         GROUP BY agent_id_snapshot
+         ORDER BY duration_ms DESC, earliest_started_at, agent_id_snapshot
+         LIMIT 1`)
+            .get(batch.id);
+        if (winner) {
+            const target = this.rawClient
+                .prepare(`SELECT id
+           FROM epics
+           WHERE project_id = ? AND agent_id = ?
+           ORDER BY updated_at DESC, id DESC
+           LIMIT 1`)
+                .get(batch.project_id, batch.lead_agent_id_snapshot);
+            this.rawClient
+                .prepare(`DELETE FROM epic_time_segments
+           WHERE team_batch_id = ? AND epic_id IS NULL AND agent_id_snapshot <> ?`)
+                .run(batch.id, winner.agent_id_snapshot);
+            this.rawClient
+                .prepare(`UPDATE epic_time_segments
+           SET epic_id = ?, agent_id_snapshot = ?, agent_name_snapshot = ?,
+               attribution_source = 'team', updated_at = ?
+           WHERE team_batch_id = ? AND epic_id IS NULL AND agent_id_snapshot = ?`)
+                .run(target?.id ?? null, batch.lead_agent_id_snapshot, batch.lead_agent_name_snapshot, nowIso, batch.id, winner.agent_id_snapshot);
+        }
+        this.rawClient.prepare(`DELETE FROM epic_time_team_batches WHERE id = ?`).run(batch.id);
     }
     loadSession(sessionId) {
         return (this.rawClient
@@ -284,15 +777,23 @@ let EpicTimeStore = class EpicTimeStore {
            WHERE s.id = ?`)
             .get(sessionId) ?? null);
     }
-    mapSummarySegment(row, rootEpicId, isDirect) {
+    mapSummarySegment(row, rootEpicId, isDirect, groupEpicId, groupEpicTitle) {
+        const attributionSource = row.attribution_source === 'team' && row.team_id_snapshot && row.team_name_snapshot
+            ? 'team'
+            : 'direct';
         return {
             id: row.id,
             rootEpicId,
             epicId: row.epic_id,
             epicTitle: row.epic_title,
+            groupEpicId,
+            groupEpicTitle,
             isDirect,
             agentId: row.agent_id_snapshot,
             agentName: row.agent_name_snapshot,
+            attributionSource,
+            teamId: attributionSource === 'team' ? row.team_id_snapshot : null,
+            teamName: attributionSource === 'team' ? row.team_name_snapshot : null,
             durationMs: row.duration_ms,
             lastActivityAt: row.last_activity_at,
             updatedAt: row.updated_at,
@@ -307,7 +808,9 @@ let EpicTimeStore = class EpicTimeStore {
     }
     loadOpenSegment(sessionId) {
         return (this.rawClient
-            .prepare(`SELECT id, project_id, epic_id, agent_id_snapshot, last_activity_at, duration_ms
+            .prepare(`SELECT id, project_id, epic_id, team_batch_id, attribution_source,
+                  team_id_snapshot, team_name_snapshot, agent_id_snapshot,
+                  last_activity_at, duration_ms
            FROM epic_time_segments
            WHERE session_id_snapshot = ? AND closed_at IS NULL`)
             .get(sessionId) ?? null);
@@ -356,6 +859,21 @@ let EpicTimeStore = class EpicTimeStore {
            WHERE earliest.project_id = s.project_id
              AND earliest.agent_id_snapshot = s.agent_id_snapshot
              AND earliest.published_at >= s.started_at
+             AND (
+               s.team_batch_id IS NULL
+               OR EXISTS (
+                 SELECT 1
+                 FROM epic_time_team_batches open_batch
+                 WHERE open_batch.id = s.team_batch_id
+                   AND open_batch.sealed_at IS NULL
+               )
+               OR EXISTS (
+                 SELECT 1
+                 FROM epic_time_team_batch_event_barriers barrier
+                 WHERE barrier.team_batch_id = s.team_batch_id
+                   AND barrier.committed_event_id = earliest.committed_event_id
+               )
+             )
            ORDER BY earliest.published_at, earliest.claim_sequence
            LIMIT 1
          )
@@ -368,7 +886,21 @@ let EpicTimeStore = class EpicTimeStore {
         const discardedSegmentIds = new Set();
         const targetExists = new Map();
         const updateSegment = this.rawClient.prepare(`UPDATE epic_time_segments
-       SET epic_id = ?, updated_at = ?
+       SET epic_id = ?,
+           attribution_source = CASE
+             WHEN team_batch_id IS NOT NULL THEN 'direct'
+             ELSE attribution_source
+           END,
+           team_id_snapshot = CASE
+             WHEN team_batch_id IS NOT NULL THEN NULL
+             ELSE team_id_snapshot
+           END,
+           team_name_snapshot = CASE
+             WHEN team_batch_id IS NOT NULL THEN NULL
+             ELSE team_name_snapshot
+           END,
+           team_batch_id = NULL,
+           updated_at = ?
        WHERE id = ? AND epic_id IS NULL`);
         const deleteSegment = this.rawClient.prepare(`DELETE FROM epic_time_segments
        WHERE id = ? AND epic_id IS NULL`);
@@ -395,6 +927,33 @@ let EpicTimeStore = class EpicTimeStore {
         }
         return { claimedSegmentIds, discardedSegmentIds };
     }
+    requireCapturedBufferRows(input) {
+        const rows = this.listEligibleBufferRows(input.projectId, input.agentId);
+        const capturedAtMs = this.timestampMs(input.capturedAt);
+        if (rows.length === 0 || rows.some((row) => this.timestampMs(row.updated_at) > capturedAtMs)) {
+            throw new error_types_1.ConflictError(STALE_SNAPSHOT_MESSAGE);
+        }
+        if (buildBufferSnapshotToken(input.projectId, input.agentId, rows) !== input.snapshotToken) {
+            throw new error_types_1.ConflictError(STALE_SNAPSHOT_MESSAGE);
+        }
+        return rows;
+    }
+    listEligibleBufferRows(projectId, agentId) {
+        return this.rawClient
+            .prepare(`SELECT seg.id, seg.agent_id_snapshot, seg.duration_ms, seg.started_at,
+                seg.last_activity_at, seg.closed_at, seg.updated_at
+         FROM epic_time_segments seg
+         INNER JOIN agents a
+           ON a.id = seg.agent_id_snapshot AND a.project_id = seg.project_id
+         WHERE seg.project_id = ?
+           AND (? IS NULL OR seg.agent_id_snapshot = ?)
+           AND seg.epic_id IS NULL
+           AND seg.team_batch_id IS NULL
+           AND seg.closed_at IS NOT NULL
+           AND seg.duration_ms > 0
+         ORDER BY seg.agent_id_snapshot, seg.started_at, seg.id`)
+            .all(projectId, agentId, agentId);
+    }
     closeSegment(segmentId, closedAt, nowIso) {
         this.rawClient
             .prepare(`UPDATE epic_time_segments