crewly 1.20.204 → 1.20.206

package/dist/backend/backend/src/services/project-tickets/ticket-autopilot.service.js

@@ -10,6 +10,10 @@
  * - brakes hold: a daily USD budget over the team's agents (pauses the
  *   autopilot and ticket auto-claim for the day, owner told once) and an
  *   in-progress cap per member ({@link ProjectTicketAutopilotPolicy});
+ * - when the project has a goal but nothing is left to triage and someone is
+ *   idle, the driver is woken with ONE `goal_replan` WorkItem to open the
+ *   next tickets toward the goal (at most `replansPerDay` a day, same budget
+ *   and in-progress brakes; specs/2026-10-04-autopilot-goal-replan.md);
  * - owner questions are decision cards (specs/2026-10-01-decision-cards.md),
  *   posted by the asking agent in the ticket's thread; the owner gets one
  *   evening digest (skipped when nothing changed) that links to open cards.
@@ -28,9 +32,9 @@ import { applyTicketAutopilotInput, legacyBudgetTokens, resolveTicketAutopilotSe
 import { ProjectTicketError } from './project-ticket.service.js';
 import { getTeamLeads } from '../../utils/team.utils.js';
 import { isTeamLead, } from './project-ticket-workflow.service.js';
-import { OPEN_TICKET_STATUSES, decideDigest, decideTriage, hasNeedsOwnerLabel, inFlightByAssignee, isMemberIdle, localDateKey, memberAvailability, memberResponsibility, localMidnight, selectTriageCandidates, } from './ticket-autopilot-decision.js';
-import { buildBudgetPausedMessage, buildDigestMessage, buildTriageBrief, } from './ticket-autopilot-messages.js';
-import { autopilotRunTrace, startTriageTrace, traceAutopilotAction, createAutopilotTicketListener } from './ticket-autopilot-trace.js';
+import { OPEN_TICKET_STATUSES, closedTicketsSince, decideDigest, decideReplan, decideTriage, nextReplanBackoff, replanBackoffState, hasNeedsOwnerLabel, inFlightByAssignee, isMemberIdle, localDateKey, memberAvailability, memberResponsibility, localMidnight, selectTriageCandidates, } from './ticket-autopilot-decision.js';
+import { buildBudgetPausedMessage, buildDigestMessage, buildReplanBrief, buildTriageBrief, REPLAN_ASK, } from './ticket-autopilot-messages.js';
+import { autopilotRunTrace, startReplanTrace, startTriageTrace, traceAutopilotAction, createAutopilotTicketListener } from './ticket-autopilot-trace.js';
 import { computeAutopilotStats, dayEndMs, daysBetween, dayStartMs, rangeDays, } from './ticket-autopilot-stats.js';
 import { buildRetroBrief, duplicateOf, renderRetroMarkdown, RetroInputError, validateRetroInput, } from './ticket-autopilot-retro.js';
 import { getTraceStore } from '../trace/trace-store.js';
@@ -40,6 +44,7 @@ const SKIP_WORDS = {
     no_driver: 'no team lead to drive it',
     budget_reached: 'daily budget reached',
     triage_in_flight: 'a triage is still open',
+    replan_in_flight: 'a goal replan is still open',
     nothing_to_triage: 'nothing to triage',
     nobody_idle: 'nobody on the team is idle',
     too_soon: 'too soon after the last triage',
@@ -283,7 +288,8 @@ export class TicketAutopilotService {
             await this.noticeBudgetPaused(project, ps, spent, budget, now, teams[0]?.name);
         this.traceBudgetState(project, ps, settings.enabled && spent >= budget, spent, budget, now);
         const { tickets } = await this.deps.tickets.list(project.path);
-        const live = await this.liveTriageItem(project, nowMs);
+        const live = await this.liveItem(project, nowMs, TICKET_AUTOPILOT_CONSTANTS.TRIAGE_METADATA_KIND);
+        const liveReplan = await this.liveItem(project, nowMs, TICKET_AUTOPILOT_CONSTANTS.REPLAN_METADATA_KIND, settings.replanTtlHours);
         const selection = selectTriageCandidates({ tickets, teams, now: nowMs, listed: ps.listed });
         const members = teams.flatMap((t) => t.members ?? []);
         const anyoneIdle = (!!idleSession && members.some((m) => sessionOf(m) === idleSession || m.sessionName === idleSession)) || members.some((m) => isMemberIdle(m));
@@ -294,45 +300,46 @@ export class TicketAutopilotService {
             now: nowMs,
             candidateCount: selection.candidates.length,
             liveTriage: !!live,
+            ...(liveReplan ? { liveReplanAt: Date.parse(liveReplan.createdAt) || nowMs } : {}),
             lastTriageAt: ps.lastTriageAt,
             anyoneIdle,
             usedTodayTokens: spent,
             dailyBudgetTokens: budget,
         });
         if (decision.action === 'skip' || !driver) {
+            // Nothing to triage: a project with a goal may wake its driver to plan
+            // the next tickets instead (specs/2026-10-04-autopilot-goal-replan.md).
+            if (decision.action === 'skip' && decision.reason === 'nothing_to_triage' && driver) {
+                const replan = await this.evaluateReplan(project, {
+                    settings,
+                    ps,
+                    driver,
+                    trigger,
+                    now,
+                    tickets,
+                    teams,
+                    idleSession,
+                    spent,
+                    budget,
+                    liveTriage: !!live,
+                    liveReplanId: liveReplan?.id ?? null,
+                    candidateCount: selection.candidates.length,
+                    anyoneIdle,
+                });
+                if (replan?.workItem)
+                    return { projectId: project.id, decision, replan: replan.decision, workItem: replan.workItem };
+                this.logger.debug('Ticket autopilot: no triage', { projectId: project.id, trigger, decision, replan: replan?.decision });
+                this.traceSkip(project, ps, decision.reason, trigger, selection.candidates.length, now);
+                await this.saveState();
+                return { projectId: project.id, decision, ...(replan ? { replan: replan.decision } : {}) };
+            }
             this.logger.debug('Ticket autopilot: no triage', { projectId: project.id, trigger, decision });
             if (decision.action === 'skip')
                 this.traceSkip(project, ps, decision.reason, trigger, selection.candidates.length, now);
             await this.saveState();
             return { projectId: project.id, decision };
         }
-        const inFlight = inFlightByAssignee(tickets);
-        const seen = new Set();
-        const roster = teams.flatMap((t) => (t.members ?? [])
-            .filter((m) => {
-            const s = sessionOf(m);
-            if (!s || seen.has(s))
-                return false;
-            seen.add(s);
-            return true;
-        })
-            .map((m) => ({ team: t, m })));
-        const roleLines = await this.roleDescriptions(roster.map(({ m }) => m.role));
-        const briefMembers = roster.map(({ team: t, m }) => {
-            const session = sessionOf(m);
-            // Stopped (idle-stopped, suspended) is "available — started when
-            // assigned", never "busy"; its in-progress count is its real one.
-            const availability = session === idleSession && memberAvailability(m) !== 'stopped' ? 'idle' : memberAvailability(m);
-            return {
-                session,
-                name: m.name,
-                role: m.role,
-                lead: isTeamLead(t, m),
-                availability,
-                responsibility: memberResponsibility(m, roleLines.get(String(m.role ?? ''))),
-                inFlight: inFlight.get(session) ?? 0,
-            };
-        });
+        const briefMembers = await this.briefMembers(teams, tickets, idleSession);
         const brief = buildTriageBrief({
             project: { id: project.id, name: project.name },
             candidates: selection.candidates,
@@ -390,22 +397,278 @@ export class TicketAutopilotService {
         return { projectId: project.id, decision, workItem };
     }
     /**
-     * The project's live triage item, if any. A triage item still queued
-     * (never picked up) after {@link TICKET_AUTOPILOT_CONSTANTS.TRIAGE_STALE_QUEUED_MS}
-     * is cancelled so a fresh one can replace it.
+     * Evaluate a goal replan for a project with nothing to triage and, when
+     * {@link decideReplan} says so, wake the driver with ONE `goal_replan`
+     * WorkItem: the goal, the tickets closed lately, open experiment cards and
+     * the ask. The driver opens the tickets; the autopilot never makes them
+     * ready or starts work.
+     *
+     * @param project - Project
+     * @param c - The evaluation's state
+     * @returns The decision and the WorkItem created, or null when the project has no goal (nothing changes)
+     */
+    async evaluateReplan(project, c) {
+        const C = TICKET_AUTOPILOT_CONSTANTS;
+        // No goal reader: never replans; the evaluation is as before.
+        if (!this.deps.goalOf)
+            return null;
+        const nowMs = c.now.getTime();
+        const today = localDateKey(c.now);
+        const inFlight = inFlightByAssignee(c.tickets);
+        const members = c.teams.flatMap((t) => t.members ?? []);
+        const isIdle = (m) => isMemberIdle(m) || (!!c.idleSession && (sessionOf(m) === c.idleSession || m.sessionName === c.idleSession));
+        const held = (m) => Math.max(inFlight.get(sessionOf(m)) ?? 0, m.sessionName ? inFlight.get(m.sessionName) ?? 0 : 0, m.agentId ? inFlight.get(m.agentId) ?? 0 : 0);
+        const idleWithRoom = members.some((m) => isIdle(m) && held(m) < c.settings.maxInFlightPerMember);
+        const replansToday = c.ps.replans?.day === today ? c.ps.replans.count : 0;
+        // The last replan is over: did it open tickets? None → back off longer.
+        this.assessLastReplan(project, c.ps, c.tickets, c.liveReplanId, nowMs);
+        // Cheap gates first (in-memory state only); the goal is read last.
+        const gates = {
+            enabled: c.settings.enabled,
+            driver: c.driver.session,
+            maxReplansPerDay: c.settings.replansPerDay,
+            replansToday,
+            usedTodayTokens: c.spent,
+            dailyBudgetTokens: c.budget,
+            liveTriage: c.liveTriage,
+            liveReplan: !!c.liveReplanId,
+            candidateCount: c.candidateCount,
+            anyoneIdle: c.anyoneIdle,
+            idleWithRoom,
+        };
+        const skip = (d) => {
+            this.logger.debug('Ticket autopilot: no goal replan', { projectId: project.id, trigger: c.trigger, decision: d });
+            return { decision: d };
+        };
+        const pre = decideReplan({ ...gates, backedOff: false, hasGoal: true });
+        if (pre.action === 'skip')
+            return skip(pre);
+        // Backoff after empty replans: lifted by a new ticket or a goal / OKR
+        // change (file times only).
+        let backedOff = false;
+        if (c.ps.replanBackoff) {
+            const changedAt = this.deps.goalChangedAt ? await this.deps.goalChangedAt(project).catch(() => null) : null;
+            const state = replanBackoffState(c.ps.replanBackoff, { today, tickets: c.tickets, goalChangedAt: changedAt });
+            if (state === 'lifted') {
+                this.logger.info('Goal replan backoff lifted (new ticket or goal change)', { projectId: project.id, streak: c.ps.replanBackoff.streak });
+                delete c.ps.replanBackoff;
+                await this.saveState();
+            }
+            backedOff = state === 'holds';
+        }
+        if (backedOff)
+            return skip(decideReplan({ ...gates, backedOff, hasGoal: true }));
+        const goal = await this.deps.goalOf(project, c.now).catch((err) => {
+            this.logger.warn('Could not read the project goal (no replan)', { projectId: project.id, error: err instanceof Error ? err.message : String(err) });
+            return null;
+        });
+        // No goal: the evaluation is what it was before goal replans.
+        if (!goal || !goal.text.trim())
+            return null;
+        const decision = decideReplan({ ...gates, backedOff, hasGoal: true });
+        if (decision.action === 'skip')
+            return skip(decision);
+        const closed = closedTicketsSince(c.tickets, nowMs - C.REPLAN_CLOSED_LOOKBACK_DAYS * 24 * 60 * 60 * 1000, C.REPLAN_MAX_CLOSED_TICKETS);
+        const experiments = this.deps.openExperiments ? await this.deps.openExperiments(project).catch(() => []) : [];
+        const brief = buildReplanBrief({
+            project: { id: project.id, name: project.name },
+            goal: goal.text,
+            closed,
+            lookbackDays: C.REPLAN_CLOSED_LOOKBACK_DAYS,
+            experiments,
+            members: await this.briefMembers(c.teams, c.tickets, c.idleSession),
+            maxInFlightPerMember: c.settings.maxInFlightPerMember,
+            now: nowMs,
+        });
+        const workItem = createWorkItem({
+            type: C.REPLAN_WORK_ITEM_TYPE,
+            owner: 'team_lead',
+            target: c.driver.session,
+            title: `Plan next tickets toward the goal: ${project.name}`,
+            description: `Nothing is left to triage on ${project.name}. ${REPLAN_ASK}`,
+            briefMarkdown: capBrief(brief),
+            metadata: {
+                kind: C.REPLAN_METADATA_KIND,
+                projectId: project.id,
+                projectPath: project.path,
+                teamId: c.driver.teamId,
+                requiresVerification: false,
+                trigger: c.trigger,
+                goalSources: goal.sources,
+                closedTicketIds: closed.map((t) => t.id),
+                experimentIds: experiments.map((e) => e.id),
+            },
+        });
+        workItem.createdAt = c.now.toISOString();
+        workItem.targetSource = 'assigned';
+        const replanTrace = startReplanTrace(project, c.now);
+        if (replanTrace)
+            workItem.traceId = replanTrace;
+        await this.deps.pool.addToPool(workItem);
+        const count = replansToday + 1;
+        c.ps.replans = { day: today, count, lastAt: nowMs, lastWorkItemId: workItem.id, assessed: false };
+        // A replan is autopilot work: it starts the day's run trace. Not an owner touch.
+        traceAutopilotAction(project, 'replan', {
+            summary: `${project.name}: ${c.driver.session} woken to plan the next tickets toward the goal (nothing left to triage)`,
+            outcome: 'queued',
+            workItemId: workItem.id,
+            session: c.driver.session,
+            data: {
+                trigger: c.trigger,
+                goalSources: goal.sources.join(','),
+                closed: closed.length,
+                experiments: experiments.length,
+                replansToday: count,
+                replansPerDay: c.settings.replansPerDay,
+            },
+            alsoTraceId: workItem.traceId ?? null,
+            now: c.now,
+        });
+        await this.saveState();
+        this.logger.info('Ticket autopilot woke the driver to plan toward the goal', {
+            projectId: project.id,
+            driver: c.driver.session,
+            trigger: c.trigger,
+            workItemId: workItem.id,
+            replansToday: count,
+        });
+        return { decision, workItem };
+    }
+    /**
+     * The team section of a brief: every member once, with availability,
+     * role line and in-progress count.
+     *
+     * @param teams - Project teams
+     * @param tickets - Project tickets (in-progress counts)
+     * @param idleSession - The member that just went idle
+     * @returns Brief members
+     */
+    async briefMembers(teams, tickets, idleSession) {
+        const inFlight = inFlightByAssignee(tickets);
+        const seen = new Set();
+        const roster = teams.flatMap((t) => (t.members ?? [])
+            .filter((m) => {
+            const s = sessionOf(m);
+            if (!s || seen.has(s))
+                return false;
+            seen.add(s);
+            return true;
+        })
+            .map((m) => ({ team: t, m })));
+        const roleLines = await this.roleDescriptions(roster.map(({ m }) => m.role));
+        return roster.map(({ team: t, m }) => {
+            const session = sessionOf(m);
+            // Stopped (idle-stopped, suspended) is "available — started when
+            // assigned", never "busy"; its in-progress count is its real one.
+            const availability = session === idleSession && memberAvailability(m) !== 'stopped' ? 'idle' : memberAvailability(m);
+            return {
+                session,
+                name: m.name,
+                role: m.role,
+                lead: isTeamLead(t, m),
+                availability,
+                responsibility: memberResponsibility(m, roleLines.get(String(m.role ?? ''))),
+                inFlight: inFlight.get(session) ?? 0,
+            };
+        });
+    }
+    /**
+     * Record the outcome of the last goal replan once it is no longer live:
+     * a ticket created since it was queued clears the backoff; none ("there
+     * are none") backs off one step longer (2, 4, 7 days).
+     *
+     * @param project - Project
+     * @param ps - Its bookkeeping
+     * @param tickets - Its tickets
+     * @param liveReplanId - The live replan, if any
+     * @param nowMs - Clock
+     */
+    assessLastReplan(project, ps, tickets, liveReplanId, nowMs) {
+        const last = ps.replans;
+        if (!last?.lastWorkItemId || last.lastAt === undefined || last.assessed !== false)
+            return;
+        if (liveReplanId === last.lastWorkItemId)
+            return;
+        const next = nextReplanBackoff({ replanAt: last.lastAt, replanDay: last.day, tickets, previous: ps.replanBackoff, now: nowMs });
+        if (next)
+            ps.replanBackoff = next;
+        else
+            delete ps.replanBackoff;
+        last.assessed = true;
+        this.logger.info(next ? 'Goal replan opened no tickets: backing off' : 'Goal replan opened tickets', {
+            projectId: project.id,
+            workItemId: last.lastWorkItemId,
+            ...(next ? { streak: next.streak, resumeDay: next.resumeDay } : {}),
+        });
+    }
+    /**
+     * Expire a goal replan past its TTL so it cannot hold triage forever:
+     * cancelled where the pool allows it (queued / blocked / scheduled,
+     * running, proposed / accepted / escalated). One the driver already
+     * finished (`done_by_worker`) waits on a verdict the autopilot cannot
+     * give; it is only no longer counted as live.
+     *
+     * @param project - Project
+     * @param wi - The replan
+     * @param ttlHours - Its TTL
+     */
+    async expireReplan(project, wi, ttlHours) {
+        const reason = `goal replan still open after ${ttlHours}h; expired by the ticket autopilot`;
+        const pool = this.deps.pool;
+        try {
+            if (wi.status === 'queued' || wi.status === 'blocked' || wi.status === 'scheduled') {
+                await pool.cancelQueued(wi.id, reason);
+            }
+            else if (wi.status === 'running') {
+                await pool.releaseClaim?.(wi.id, reason);
+                await pool.transitionStatus?.(wi.id, 'cancelled', 'system', undefined, reason);
+            }
+            else if (wi.status === 'proposed' || wi.status === 'accepted' || wi.status === 'escalated') {
+                await pool.transitionStatus?.(wi.id, 'cancelled', 'system', undefined, reason);
+            }
+            else {
+                this.logger.debug('Expired goal replan left as is (not cancellable from its status)', { projectId: project.id, workItemId: wi.id, status: wi.status });
+                return;
+            }
+            this.logger.info('Goal replan expired', { projectId: project.id, workItemId: wi.id, status: wi.status, ttlHours });
+        }
+        catch (err) {
+            // Still expired: it no longer holds triage even if the pool refused.
+            this.logger.warn('Could not cancel an expired goal replan (no longer counted as live)', {
+                projectId: project.id,
+                workItemId: wi.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /**
+     * The project's live autopilot item of a kind (triage or goal replan), if
+     * any. A triage still queued (never picked up) after
+     * {@link TICKET_AUTOPILOT_CONSTANTS.TRIAGE_STALE_QUEUED_MS} is cancelled so
+     * a fresh one can replace it. A replan older than its TTL in any live
+     * status is expired ({@link expireReplan}) and not returned.
      *
      * @param project - Project
      * @param nowMs - Clock
+     * @param kind - `metadata.kind` (triage or replan)
+     * @param replanTtlHours - Replan TTL (replan kind only)
      * @returns The live item, or null
      */
-    async liveTriageItem(project, nowMs) {
-        const items = (await this.deps.pool.getAllItems()).filter((wi) => wi.metadata?.kind === TICKET_AUTOPILOT_CONSTANTS.TRIAGE_METADATA_KIND && wi.metadata?.projectId === project.id && LIVE_STATUSES.has(wi.status));
+    async liveItem(project, nowMs, kind, replanTtlHours) {
+        const items = (await this.deps.pool.getAllItems()).filter((wi) => wi.metadata?.kind === kind && wi.metadata?.projectId === project.id && LIVE_STATUSES.has(wi.status));
+        const what = kind === TICKET_AUTOPILOT_CONSTANTS.REPLAN_METADATA_KIND ? 'goal replan' : 'ticket triage';
         let live = null;
         for (const wi of items) {
             const age = nowMs - (Date.parse(wi.createdAt) || nowMs);
-            if (wi.status === 'queued' && age >= TICKET_AUTOPILOT_CONSTANTS.TRIAGE_STALE_QUEUED_MS) {
-                await this.deps.pool.cancelQueued(wi.id, 'ticket triage never picked up; replaced by a fresh one').catch(() => undefined);
-                this.logger.info('Stale ticket triage cancelled', { projectId: project.id, workItemId: wi.id });
+            if (replanTtlHours !== undefined) {
+                if (age >= replanTtlHours * 60 * 60 * 1000) {
+                    await this.expireReplan(project, wi, replanTtlHours);
+                    continue;
+                }
+            }
+            else if (wi.status === 'queued' && age >= TICKET_AUTOPILOT_CONSTANTS.TRIAGE_STALE_QUEUED_MS) {
+                await this.deps.pool.cancelQueued(wi.id, `${what} never picked up; replaced by a fresh one`).catch(() => undefined);
+                this.logger.info(`Stale ${what} cancelled`, { projectId: project.id, workItemId: wi.id });
                 continue;
             }
             live = wi;
@@ -878,7 +1141,7 @@ export class TicketAutopilotService {
             ps.retroScheduledFor = day;
             // Only a day with real autopilot work gets a retro (skips and budget
             // notices alone are not a run).
-            if (dayStats.triaged + dayStats.started + dayStats.done + dayStats.verified === 0) {
+            if (dayStats.triaged + dayStats.replans + dayStats.started + dayStats.done + dayStats.verified === 0) {
                 this.logger.debug('Autopilot retro skipped: no autopilot work that day', { projectId: project.id, day });
                 continue;
             }
@@ -1178,7 +1441,15 @@ export class TicketAutopilotService {
         const budget = this.budgetToday(settings, teams);
         const state = await this.loadState();
         const ps = state.projects[project.id];
-        const live = (await this.deps.pool.getAllItems()).some((wi) => wi.metadata?.kind === TICKET_AUTOPILOT_CONSTANTS.TRIAGE_METADATA_KIND && wi.metadata?.projectId === project.id && LIVE_STATUSES.has(wi.status));
+        const items = await this.deps.pool.getAllItems();
+        const nowMs = this.now().getTime();
+        const ttlMs = settings.replanTtlHours * 60 * 60 * 1000;
+        const liveOf = (kind) => items.some((wi) => wi.metadata?.kind === kind &&
+            wi.metadata?.projectId === project.id &&
+            LIVE_STATUSES.has(wi.status) &&
+            (kind !== TICKET_AUTOPILOT_CONSTANTS.REPLAN_METADATA_KIND || nowMs - (Date.parse(wi.createdAt) || nowMs) < ttlMs));
+        const live = liveOf(TICKET_AUTOPILOT_CONSTANTS.TRIAGE_METADATA_KIND);
+        const today = localDateKey(this.now());
         return {
             project: { id: project.id, name: project.name, path: project.path },
             settings,
@@ -1189,6 +1460,10 @@ export class TicketAutopilotService {
             pausedForToday: settings.enabled && spent >= budget.tokens,
             triageInFlight: live,
             lastTriageAt: ps?.lastTriageAt ? new Date(ps.lastTriageAt).toISOString() : null,
+            replanInFlight: liveOf(TICKET_AUTOPILOT_CONSTANTS.REPLAN_METADATA_KIND),
+            replansToday: ps?.replans?.day === today ? ps.replans.count : 0,
+            lastReplanAt: ps?.replans?.lastAt ? new Date(ps.replans.lastAt).toISOString() : null,
+            replanBackoffUntil: ps?.replanBackoff && today < ps.replanBackoff.resumeDay ? ps.replanBackoff.resumeDay : null,
             retroOn: await this.retroOn(project),
         };
     }