@onepointfour-packs/flaredeck-agent 0.2.193 → 0.2.195

package/dist/serve.js

@@ -29,7 +29,7 @@ class RetryOnAnotherPlan extends CouldNotWork {
 }
 import { isJustReading, jevGuard, judgeCommand } from './jevguard.js';
 import { loadProviders } from './providers.js';
-import { cardWorkOnBase, currentBranch, ensureWorktree, finishRefusalStands, freeDiskBytes, sweepWorktrees, releaseSharedPushGuard, existingWorktree, produced, releaseWorktree, tooEarlyToFinish, uncommittedCount, worktreeBrief } from './worktree.js';
+import { cardWorkOnBase, currentBranch, ensureWorktree, finishRefusalStands, freeDiskBytes, headOf, leadGaveItBack, sweepWorktrees, releaseSharedPushGuard, existingWorktree, produced, releaseWorktree, tooEarlyToFinish, uncommittedCount, worktreeBrief } from './worktree.js';
 import { askingForComponent, checkouts, repoIdentity, resolveCheckout, voteByCode, workspaceBrief, describeCheckout } from './workspace.js';
 import { chooseRepoWithJev } from './jev.js';
 import { ROUTE, intake, intakeText, unclearBrief } from './intake.js';
@@ -92,6 +92,33 @@ export function nothingOutstanding(text) {
         return false;
     return text.includes('*Nothing to do here. 🎉*') && text.includes('*No unactioned comments or mentions. 🎉*') && !/^### \d+\./m.test(text);
 }
+/** Tools that only look: reading files, searching, asking FlareDeck or a service what is there. */
+export function onlyLooks(tool) {
+    if (['Read', 'Grep', 'Glob', 'LS', 'ToolSearch', 'TodoWrite', 'TaskOutput', 'LSP', 'WebFetch', 'WebSearch', 'Monitor', 'Skill'].includes(tool))
+        return true;
+    const op = tool.startsWith('mcp__') ? tool.split('__').slice(2).join('__') : '';
+    return /^(get|find|list|read|search|health|hello|whats|check|describe|site_map|see_screen|browser_look|browser_screenshot|browser_events|pull_request_status|preview)/i.test(op);
+}
+/** Record a tool call against the session it ran in. */
+export function noteHandoverTool(logs, key, tool, at) {
+    const l = logs.get(key) ?? {};
+    if (/__set-card-notes$/.test(tool))
+        l.notesAt = at;
+    else if (!onlyLooks(tool))
+        l.changedAt = at;
+    logs.set(key, l);
+}
+/**
+ * Whether a session ending needs a handover note: it changed something, after its last notes.
+ * Unknown (no record) is treated as needed, as before.
+ */
+export function handoverNeeded(l) {
+    if (!l)
+        return true;
+    if (!l.changedAt)
+        return false;
+    return !l.notesAt || l.changedAt > l.notesAt;
+}
 /** How long after a card's turn the harness leaves it alone, unless an event brings it back. */
 export const RESUME_COOLDOWN_MS = 15 * 60_000;
 /** Whether any of these ids had a turn within the cooldown. */
@@ -488,8 +515,8 @@ export async function serve(opts) {
             const isJam = (m) => m.name === 'jam' || /(^|\.)jam\.dev\b/.test(new URL(m.url).hostname);
             const { setJamFromFlaredeck } = await import('./jam.js');
             setJamFromFlaredeck(hydrated.mcpServers.some((m) => isJam(m) && m.token)
-                ? async () => {
-                    await refreshMcp();
+                ? async (fresh) => {
+                    await refreshMcp(fresh === true);
                     return (config.mcpServers ?? []).find((m) => isJam(m) && m.token)?.token ?? null;
                 }
                 : null);
@@ -1008,6 +1035,8 @@ export async function serve(opts) {
     const keepTool = (name) => offeredTo(isManager || isAssistant ? 'manager' : isLead ? 'lead' : 'worker', name);
     /** Cards already handed to the lead, so a retried tool call does not assign or message twice. */
     const handedBack = new Set();
+    /** The branch head when each card was handed to the lead: unchanged, a card given back is the lead's "move it". */
+    const handedBackHead = new Map();
     try {
         const team = await fetchTeam(opts.baseUrl, await opts.auth());
         // Who is an agent, so a parked card can tell a person answering from agents talking shop.
@@ -1544,6 +1573,30 @@ export async function serve(opts) {
      */
     const signInPending = new Map();
     const SIGN_IN_HOLD_MS = 2 * 60 * 60_000;
+    /**
+     * Stop this agent's environments for its other cards before starting one for this card. An agent
+     * works one card at a time, and the other card's servers hold the ports: CASE could not rerun its
+     * HR-1091 browser check because HR-1074's environment still served on them (20 Oct), and JARVIS
+     * hit the same twice on 19 Oct. A checkout with a sign-in waiting on a person is left up.
+     */
+    const stopOtherEnvironments = async (cwd) => {
+        for (const other of [...envUp.keys()]) {
+            if (other === cwd)
+                continue;
+            const waiting = signInPending.get(other);
+            if (waiting && Date.now() - waiting < SIGN_IN_HOLD_MS)
+                continue;
+            const timer = idleStops.get(other);
+            if (timer) {
+                clearTimeout(timer);
+                idleStops.delete(other);
+            }
+            envUp.delete(other);
+            const ok = await stopEnvironment(other).catch(() => false);
+            if (ok)
+                log('tool', `environment stopped in ${other.split('/').pop()} — another card's, and this card needs its ports`);
+        }
+    };
     const scheduleEnvironmentStop = (cwd) => {
         const before = idleStops.get(cwd);
         if (before)
@@ -1782,6 +1835,8 @@ export async function serve(opts) {
         timer.unref();
         live.set(key, { cwd, tokens, timer });
     };
+    /** Per session: when it last wrote the card's notes, and last did something that changed anything. */
+    const handoverLog = new Map();
     const closeSession = async (key, done = false) => {
         const s = live.get(key);
         if (!s)
@@ -3188,8 +3243,29 @@ export async function serve(opts) {
             const code = tag || event.cardCode || event.cardKey || '';
             if (!code)
                 return null;
+            // Handed over before, and the lead has given it back with nothing new on the branch: the
+            // lead reviewed it and wants it moved on. Let the move through instead of refusing again.
+            if (handedBack.has(code) && tree && opts.deck) {
+                const [here, head] = await Promise.all([opts.deck.card(code).catch(() => null), headOf(tree)]);
+                if (leadGaveItBack(handedBackHead.get(code), head, here?.assigned_to?.uid, selfId)) {
+                    log('tool', `moving ${code} on — ${leadName} reviewed it and gave it back, nothing new since`);
+                    return null;
+                }
+                // Back with this worker and changed since (or we cannot tell): it is new work, handed to the
+                // lead again like the first time. Remembering the old hand-back forever refused HAL's second
+                // "done" on HR-1074 with "JARVIS's to verify" while the card stayed assigned to HAL (20 Oct).
+                if (here?.assigned_to?.uid && here.assigned_to.uid === selfId) {
+                    handedBack.delete(code);
+                    handedBackHead.delete(code);
+                }
+            }
             if (!handedBack.has(code)) {
                 handedBack.add(code);
+                if (tree) {
+                    const head = await headOf(tree);
+                    if (head)
+                        handedBackHead.set(code, head);
+                }
                 const made = tree ? await produced(tree) : null;
                 const where = tree
                     ? `Branch \`${tree.branch}\`${made ? ` — ${made.commits} commit(s), ${made.pushed ? 'pushed' : 'NOT pushed'}` : ''}.`
@@ -3208,6 +3284,7 @@ export async function serve(opts) {
                 catch (e) {
                     // A handback that did not happen must not read as one that did.
                     handedBack.delete(code);
+                    handedBackHead.delete(code);
                     const text = e instanceof Error ? e.message : String(e);
                     log('warn', `could not hand ${code} to ${leadName}: ${text}`);
                     return `Could not hand this card to ${leadName} for review (${text}). Do not move it; say so on the card instead.`;
@@ -3402,7 +3479,7 @@ export async function serve(opts) {
             : forACard && needsRunning
                 // The script this board declared for the repository this card is in, if it declared one.
                 // Matched on the remote, the same way the base branch is.
-                ? await startEnvironment(cwd, (t) => log('tool', t), where.kind === 'repo' ? where.script : undefined)
+                ? await stopOtherEnvironments(cwd).then(() => startEnvironment(cwd, (t) => log('tool', t), where.kind === 'repo' ? where.script : undefined))
                 : { ran: false, ok: true, endpoints: {}, detail: '' };
         if (env.ran && env.ok)
             envUp.set(cwd, env);
@@ -3445,6 +3522,7 @@ export async function serve(opts) {
                     envUp.set(cwd, started);
             },
             onNote: (t) => log('tool', t),
+            beforeStart: () => stopOtherEnvironments(cwd),
             /**
              * Turning "ask somebody" into something that actually asks.
              *
@@ -3938,6 +4016,8 @@ export async function serve(opts) {
                             log('warn', `${r.status.over.message} — Claude answers from the next turn`);
                     });
                 }
+                if (out.kind === 'tool' && !out.sub)
+                    noteHandoverTool(handoverLog, key, out.name, Date.now());
                 if (out.kind === 'tool') {
                     const stepBack = struggling.saw(out.name);
                     if (stepBack) {
@@ -4168,6 +4248,17 @@ export async function serve(opts) {
         return flaredeckProxy(config.mcpServerName, config.mcpUrl, opts.auth, check.discovered);
     }
     async function wrapUp(key, cwd, done = false) {
+        // Nothing to hand over: the session changed nothing since it last wrote the card's notes, or
+        // never changed anything. A handover reopens the whole session (often 70k-126k tokens, the
+        // cache long cold) to say so: JARVIS spent about half its turns on 20 Oct rewriting notes it
+        // had just written (HR-0759 five times in three minutes). A finished card is always handed over.
+        if (!done && !handoverNeeded(handoverLog.get(key))) {
+            log('tool', `${key}: nothing changed since the last handover — closing without another`);
+            handoverLog.delete(key);
+            sessions.delete(key);
+            return;
+        }
+        handoverLog.delete(key);
         // Resume the session the work actually happened in — NOT the options the turn started with.
         // On a new card those carry no resume id, so reusing them would open a third session and ask
         // an agent with no memory of the work to summarise it. It would answer, too.
@@ -4228,6 +4319,13 @@ export async function serve(opts) {
                     '',
                     'Keep it short. If there is genuinely nothing worth passing on, say so and write nothing —',
                     'an empty note is better than a paragraph restating the card.',
+                    '',
+                    // HAL stopped a browser check six minutes into its run on this handover, "so nothing is
+                    // left running", and the next session started it over (HR-1074, 20 Oct). The card is
+                    // not finished: the environment and a run being waited on are what the next session needs.
+                    'Do NOT stop anything that is still running: the environment, a test run or a background',
+                    'job you are waiting on. The card is not finished, and the next session on it picks those',
+                    'up. Say in the note what is still running and where its result will be.',
                 ]).join('\n'), {
                 config: { ...config, repo: cwd },
                 decider: sessionDecider,