@onepointfour-packs/flaredeck-agent 0.2.198 → 0.2.200

package/dist/serve.js

@@ -9,7 +9,7 @@ import { freshGitHubToken } from './githubauth.js';
 import { answerFrom, createPresence, heldFor, modeCommand } from './presence.js';
 import { defaultUploadRoots, fileTools, flaredeckStores } from './filestore.js';
 import { scratchFor } from './cardmess.js';
-import { fetchLadder, isSoloWorker, namedOnLadders, releaseTools } from './release.js';
+import { boardsNaming, fetchLadder, isSoloWorker, namedOnLadders, releaseTools } from './release.js';
 import { LiveFeed, liveSender, midTurnMessage, ASSISTANT_KEY, claudeProjectDir, historyMessage, recentExchanges, latestCliSession, assistantBrief, assistantIgnores, assistantPerson, asAssistantEvent, loadAssistantSession, saveAssistantSession } from './assistant.js';
 import { codePrefix, loadPrefixes, savePrefixes, SCRATCH_SWEEP_EVERY_MS, sweepScratch } from './scratch.js';
 import { findImages, namedForAgent } from './images.js';
@@ -27,6 +27,19 @@ import { CouldNotWork, engineFor } from './engine.js';
 /** The run failed on its Claude subscription — capped or token rejected — not on its work. */
 class RetryOnAnotherPlan extends CouldNotWork {
 }
+/** Where an assistant's card repositories are cloned: the harness's own folder, never its person's project. */
+export const cardReposRoot = () => join(configDir(), 'card-repos');
+/** A clone's folder: the repository's own name, made safe. */
+export const cardRepoDir = (url) => (url.replace(/\/+$/, '').split('/').pop() ?? 'repo').replace(/\.git$/i, '').replace(/[^A-Za-z0-9._-]/g, '-') || 'repo';
+/**
+ * The turn failed before the model ran. `spawn ETXTBSY`: the harness's own update was rewriting
+ * the Claude binary at the moment the turn started it. Counted as done, the event was acknowledged
+ * and lost — JARVIS's review of HR-1106 (20 Oct), two handover notes before it.
+ */
+export function neverStarted(e) {
+    const code = e?.code;
+    return code === 'ETXTBSY' || /\bspawn ETXTBSY\b/.test(e instanceof Error ? e.message : String(e));
+}
 import { isJustReading, jevGuard, judgeCommand } from './jevguard.js';
 import { loadProviders } from './providers.js';
 import { cardWorkOnBase, currentBranch, ensureWorktree, finishRefusalStands, freeDiskBytes, headOf, leadGaveItBack, sweepWorktrees, releaseSharedPushGuard, existingWorktree, produced, releaseWorktree, tooEarlyToFinish, uncommittedCount, worktreeBrief } from './worktree.js';
@@ -1021,6 +1034,14 @@ export async function serve(opts) {
      * Looked up when the team is read and every 10 minutes, so a change on the board takes effect.
      */
     let namedReleaser = false;
+    /**
+     * The boards that name this agent as their releaser. An ASSISTANT works the cards assigned to it
+     * on these boards like a worker — its own checkout, the release tool — and stays its person's
+     * assistant everywhere else (Cobus, 20 Oct: FRIDAY releases the website, and the website's cards
+     * are assigned to it). Both have to be true: assigned to it, on a board it releases for.
+     */
+    let releaseBoards = new Set();
+    const assistantCard = (e) => isAssistant && !!(e.cardKey || e.cardCode) && !!e.boardKey && releaseBoards.has(e.boardKey);
     /**
      * One person's own agent: on no team, never dispatched to, listening only to `person`. One long
      * conversation, never handed over — the SDK compacts it — and loose rules. See ASSISTANT_BRIEF.
@@ -1178,6 +1199,7 @@ export async function serve(opts) {
                 const ladders = await Promise.all((config.boards ?? []).map((b) => fetchLadder(config.mcpUrl, releaseTenant, b.key, () => opts.auth()).catch(() => null)));
                 const was = namedReleaser;
                 namedReleaser = namedOnLadders(ladders, selfId);
+                releaseBoards = new Set(boardsNaming(ladders, selfId));
                 if (namedReleaser && !was)
                     log('tool', 'a board names you as the one who releases into an environment — you have the release tools');
             };
@@ -2185,8 +2207,9 @@ export async function serve(opts) {
             ...[...resumedIdle].filter(([, n]) => n >= RESUME_IDLE_LIMIT).map(([c]) => c),
         ])];
     const resumeOwnWork = async () => {
-        if (isAssistant)
-            return false; // an assistant has no "own work" — only its person's asks
+        // An assistant's own work is only the cards on boards it releases for; otherwise its person's asks.
+        if (isAssistant && !releaseBoards.size)
+            return false;
         /* Not `live.size`: a session kept WARM for a follow-up is a cache, not work, and blocking on
            it meant the card in progress was never resumed within fifteen minutes of any turn. */
         if (paused || !sweepsEnabled || stopping || working || queue.length)
@@ -2197,8 +2220,9 @@ export async function serve(opts) {
            of its own waiting. */
         let answer = '';
         try {
+            const pullFrom = isAssistant ? [...releaseBoards] : [...myBoards];
             answer = String(await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'pull-next-card', {
-                ...(boardArg([...myBoards]) !== undefined ? { board: boardArg([...myBoards]) } : {}),
+                ...(boardArg(pullFrom) !== undefined ? { board: boardArg(pullFrom) } : {}),
                 // Cards this harness will not work now: waiting on a person, or picked up with nothing new.
                 // Without this FlareDeck offered the same one every time — JARVIS, 16 Oct, "picking HR-0904
                 // back up … waiting on a person — left alone" round and round, never reaching another card.
@@ -2530,7 +2554,8 @@ export async function serve(opts) {
                 }
                 catch (e) {
                     // One bad event must not take the daemon down — that is the failure it exists to fix.
-                    didWork = !(e instanceof CouldNotWork);
+                    // A turn that could not even start is not done: kept, and tried again in a minute.
+                    didWork = !(e instanceof CouldNotWork) && !neverStarted(e);
                     log('warn', `${current}: ${e instanceof Error ? e.message : String(e)}`);
                     if (e instanceof RetryOnAnotherPlan)
                         switchPlan = true;
@@ -2867,6 +2892,8 @@ export async function serve(opts) {
         }, reason, kind, undefined, undefined, undefined, undefined, true);
     };
     async function handle(event) {
+        // An assistant working a card on a board it releases for is a worker for this turn.
+        const isAssistantChat = isAssistant && !assistantCard(event);
         const prefix = codePrefix(event.cardCode);
         if (prefix && !scratchPrefixes.has(prefix)) {
             scratchPrefixes.add(prefix);
@@ -2937,7 +2964,7 @@ export async function serve(opts) {
             return;
         }
         // An assistant hears its person and nothing else, and works outside the card machinery.
-        if (isAssistant) {
+        if (isAssistantChat) {
             const why = assistantIgnores(event, person?.uid ?? null);
             if (why) {
                 log('event', `${event.cardCode || event.event}: ${why} — not for ${person?.name ?? 'anyone'}'s assistant`);
@@ -2961,7 +2988,7 @@ export async function serve(opts) {
            FlareDeck hands it out by priority when the current one is done — and a comment on one gets
            a reply only. "In progress" is FlareDeck's answer, skipping cards parked on a person. */
         let queuedBehind = '';
-        if (!isLead && !isManager && !isAssistant && event.cardKey && event.event !== 'review' && event.event !== 'ask' && !sessions.has(event.cardKey)) {
+        if (!isLead && !isManager && !isAssistantChat && event.cardKey && event.event !== 'review' && event.event !== 'ask' && !sessions.has(event.cardKey)) {
             const here = await opts.deck?.card(event.cardCode || event.cardKey).catch(() => null);
             if (here && !here.done && String(here.lane?.type ?? '').toLowerCase() !== 'inprogress') {
                 const pv = String(await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'pull-next-card', {
@@ -2978,7 +3005,7 @@ export async function serve(opts) {
                 }
             }
         }
-        let key = isAssistant ? ASSISTANT_KEY : event.cardKey || (event.event === 'ask' ? 'ask' : event.event === 'sweep' ? 'sweep' : event.event === 'scheduled' ? `schedule-${event.scheduleId}` : 'inbox');
+        let key = isAssistantChat ? ASSISTANT_KEY : event.cardKey || (event.event === 'ask' ? 'ask' : event.event === 'sweep' ? 'sweep' : event.event === 'scheduled' ? `schedule-${event.scheduleId}` : 'inbox');
         let turnTokens = 0;
         let nudged = false;
         // A checkout of its own per card, so it cannot edit a working tree someone else is in.
@@ -3007,7 +3034,24 @@ export async function serve(opts) {
                 event = { ...event, baseBranches: fromCard };
         }
         let repoChoiceNote = '';
-        const where = await resolveCheckout(config.repo, event, scope, opts.agent ?? '');
+        let where = await resolveCheckout(config.repo, event, scope, opts.agent ?? '');
+        // An assistant's card for a repository that is not on this machine — its own folder is another
+        // project (FRIDAY's is an HR Goat checkout, the website is HrGoatMarketing): cloned once, with
+        // FlareDeck's GitHub connection, into the harness's own folder, and worked from there.
+        if (isAssistant && !isAssistantChat && where.kind !== 'repo') {
+            const cardRoot = cardReposRoot();
+            const gh = flaredeckGithub;
+            for (const url of new Set((event.baseBranches ?? []).map((e) => e.repository).filter(Boolean))) {
+                const dir = join(cardRoot, cardRepoDir(String(url)));
+                if (gh?.token && isEmptyFolder(dir))
+                    await cloneBoardRepos(dir, [{ url: String(url).replace(/\.git$/, '') }], gh.token, (t, warn) => log(warn ? 'warn' : 'tool', t));
+            }
+            const there = await resolveCheckout(cardRoot, event, undefined, opts.agent ?? '').catch(() => null);
+            if (there?.kind === 'repo')
+                where = there;
+            else if (!gh?.token)
+                log('warn', `${event.cardCode || event.cardKey}: its repository is not on this machine and FlareDeck has no GitHub connection to clone it with`);
+        }
         let chosen = where.kind === 'repo' ? where.checkout : null;
         let fromCard = where.kind === 'repo' && where.branch ? { branch: where.branch, role: where.role } : null;
         if (where.kind === 'ambiguous') {
@@ -3147,7 +3191,7 @@ export async function serve(opts) {
         // An assistant's very first turn, with no conversation of its own: its person's newest Claude
         // CLI session in this folder, carried on as a FORK — the history comes across, the person's
         // own session file is left as it was, and the two never write to the same place.
-        const pickedUp = isAssistant && key === ASSISTANT_KEY && !sessions.get(key) ? latestCliSession(config.repo) : null;
+        const pickedUp = isAssistantChat && key === ASSISTANT_KEY && !sessions.get(key) ? latestCliSession(config.repo) : null;
         if (pickedUp) {
             log('event', `carrying on from your Claude session ${pickedUp.slice(0, 8)} in this folder (a copy — yours is left as it is)`);
             // So the person sees, in FlareDeck, where the conversation was: the last thirty exchanges,
@@ -3169,7 +3213,7 @@ export async function serve(opts) {
         }
         // An assistant always works from the folder it was started in: that is where its person's own
         // Claude sessions live, and where `continue` finds the one to carry on.
-        const cwd = isAssistant ? config.repo : tree?.path ?? repo;
+        const cwd = isAssistantChat ? config.repo : tree?.path ?? repo;
         // Back on this checkout: whatever was waiting to take its environment down can stand down.
         turnCwd = cwd;
         const pendingStop = idleStops.get(cwd);
@@ -3806,7 +3850,7 @@ export async function serve(opts) {
            background is typed into THIS turn; if the turn has ended by then, it starts the next one
            on the card, so it is never lost and never polled for. */
         // Read from the file each turn, so turning helpers on or off needs no restart.
-        const helpersOn = !isAssistant && process.env['FLAREDECK_AGENT_HELPERS'] !== '0'
+        const helpersOn = !isAssistantChat && process.env['FLAREDECK_AGENT_HELPERS'] !== '0'
             && (loadConfig(config.repo)?.helpers ?? config.helpers) !== false;
         let thisRun = null;
         const deliverHelper = async (text) => {
@@ -3874,8 +3918,8 @@ export async function serve(opts) {
         }) : null;
         const engineContext = {
             ...(leadGoal ? { goal: leadGoal } : {}),
-            config: { ...config, repo: cwd, ...(isAssistant ? { assistantMode: true } : {}) },
-            ...(isAssistant ? { background: true } : {}),
+            config: { ...config, repo: cwd, ...(isAssistantChat ? { assistantMode: true } : {}) },
+            ...(isAssistantChat ? { background: true } : {}),
             // Only a real worktree confines anything; without one nothing is enforced here, and the
             // guard below makes sure a turn that would CHANGE code never gets that far.
             //
@@ -3891,12 +3935,12 @@ export async function serve(opts) {
             // own. Without a worktree there is nowhere legitimate to write, so the turn gets scratch
             // space and has to hand the card back instead.
             // An assistant is not confined to a checkout: it works for one person, anywhere they need.
-            ...(isAssistant ? {} : { sandbox: tree ? tree.path : scratchDir() }),
+            ...(isAssistantChat ? {} : { sandbox: tree ? tree.path : scratchDir() }),
             decider: sessionDecider,
             // Both only reachable in-process, so an out-of-process engine is handed them explicitly
             // rather than being left unable to publish and unchecked when it says it has.
             ...(job ? { publish: async () => publishBranch(job) } : {}),
-            standing: standingBrief(!!teamSet, config.style ?? process.env['FLAREDECK_AGENT_STYLE'], isAssistant),
+            standing: standingBrief(!!teamSet, config.style ?? process.env['FLAREDECK_AGENT_STYLE'], isAssistantChat, config.mcpServers),
             finish: finishGate,
             noteCard,
             keep: keepTool,
@@ -3905,7 +3949,7 @@ export async function serve(opts) {
             ...(resume ? { resume } : {}),
             // An assistant with no conversation of its own yet carries on its person's last Claude
             // session in this folder — the one they were working in before the assistant existed.
-            ...(!resume && isAssistant && key === ASSISTANT_KEY && pickedUp ? { resume: pickedUp, forkSession: true } : {}),
+            ...(!resume && isAssistantChat && key === ASSISTANT_KEY && pickedUp ? { resume: pickedUp, forkSession: true } : {}),
             ...(prepared?.model ? { model: prepared.model } : {}),
             ...(prepared?.size ? { size: prepared.size } : {}),
             ...(claudePlan?.use === 'token' ? { claudeToken: claudePlan.token } : {}),
@@ -3951,7 +3995,7 @@ export async function serve(opts) {
             freeWorkerBrief(event) + (leadWithoutCode ? LEAD_WITHOUT_CODE_BRIEF : '') +
             (queuedBehind ? `\n\nThis card is QUEUED behind ${queuedBehind}, which you are working now. Reply to what was said here if it needs a reply, and stop: do not start this card's work, change its code or move it. It is handed to you when ${queuedBehind} is done.` : '') +
             (isManager ? MANAGER_BRIEF + (event.event === 'sweep' ? MANAGER_SWEEP_BRIEF : '') : '') +
-            (isAssistant ? assistantBrief(person) : '') +
+            (isAssistantChat ? assistantBrief(person) : '') +
             // Only tell an agent about the environment when the card actually needs one running.
             environmentBrief(env, cwd, needsRunning) + notStartedBrief(forACard && !needsRunning, cwd) +
             browserBrief(env.endpoints, declaredSites, forACard, web) +
@@ -3965,7 +4009,7 @@ export async function serve(opts) {
         const run = turnEngine.run(brief + (helpersOn ? (turnEngine.name === 'antigravity' ? AGY_HELPERS_BRIEF : HELPERS_BRIEF) : ''), engineContext);
         liveRun = run;
         thisRun = run;
-        if (isAssistant)
+        if (isAssistantChat)
             liveFeed?.start(String(event.message ?? event.line ?? '').split('\n').filter(Boolean).pop() ?? '');
         // Connected MCP servers' tokens, kept current for as long as the session runs. FlareDeck hands
         // a token out with at least five minutes left, so a check every four keeps one valid.
@@ -4058,7 +4102,7 @@ export async function serve(opts) {
                 // An answer to a question typed here is the whole point of the turn, so it is shown whole;
                 // a card turn's narration is one line each, the card holds the full account.
                 // What the person watching an assistant sees: the main conversation only, not sub-agents.
-                if (isAssistant && liveFeed) {
+                if (isAssistantChat && liveFeed) {
                     if (out.kind === 'text' && !out.sub)
                         liveFeed.add('text', out.text);
                     else if (out.kind === 'tool' && !out.sub)
@@ -4141,7 +4185,7 @@ export async function serve(opts) {
         }
         clearInterval(renewTimer);
         liveRun = null;
-        if (isAssistant)
+        if (isAssistantChat)
             void liveFeed?.end();
         /**
          * The plan failed, not the work: switch plans and run this event again, now.
@@ -4175,7 +4219,7 @@ export async function serve(opts) {
             throw runError;
         // An assistant's conversation is never handed over or closed: it is one long talk with one
         // person, compacted by the SDK as it grows, and resumed after a restart from the saved id.
-        if (isAssistant)
+        if (isAssistantChat)
             return;
         // A question from the pane: no card to hand over to. Its session is kept so the next question
         // can build on this one, and simply dropped once it has grown too large to be worth carrying.
@@ -4417,7 +4461,7 @@ export async function serve(opts) {
             // rather than that the agent has gone deaf.
             // An assistant's person is the only one it listens to: anything else is dropped HERE, before
             // intake reads the card and a judge is paid to size it (FRIDAY did both for a JARVIS comment).
-            if (isAssistant) {
+            if (isAssistant && !assistantCard(event)) {
                 const why = assistantIgnores(event, person?.uid ?? null);
                 if (why) {
                     log('event', `${event.cardCode || event.event}: ${why} — not for ${person?.name ?? 'anyone'}'s assistant`);