@onepointfour-packs/flaredeck-agent 0.2.209 → 0.2.211

package/dist/serve.js

@@ -1,4 +1,5 @@
 import { hostname } from 'node:os';
+import { randomBytes } from 'node:crypto';
 import { execFile, spawn } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { createRequire } from 'node:module';
@@ -11,12 +12,13 @@ import { defaultUploadRoots, fileTools, flaredeckStores } from './filestore.js';
 import { scratchFor } from './cardmess.js';
 import { installScripts, scriptTools, SCRIPT_TOOL_NAMES } from './trusted-scripts.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 { PROFILES, profileFor, releaseRole, releasesOwnCards } from './profile.js';
+import { ASSISTANT_KEY } from './assistant.js';
 import { codePrefix, loadPrefixes, savePrefixes, SCRATCH_SWEEP_EVERY_MS, sweepScratch } from './scratch.js';
 import { findImages, namedForAgent } from './images.js';
 import { loadBaseBranch, loadMergeConfig, preflight, preflightBrief } from './preflight.js';
 import { pushStatus, StatusTracker } from './status.js';
-import { dispatchDecision, fetchTeam, myTeam, teamTools, TEAM_TOOL_NAMES } from './team.js';
+import { fetchTeam, myTeam, teamTools, TEAM_TOOL_NAMES } from './team.js';
 import { scheduleTools, SCHEDULE_TOOL_NAMES } from './schedules.js';
 import { preflightFlaredeck } from './flaredeck-check.js';
 import { callFlaredeckTool, flaredeckProxy, offeredTo } from './flaredeck-proxy.js';
@@ -25,9 +27,6 @@ import { deliverDecision, flaredeckDecider } from './approval.js';
 import { subscriptionsForAgent } from './subscriptions.js';
 import { spendFor, spendLine } from './spend.js';
 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. */
@@ -43,14 +42,13 @@ export function neverStarted(e) {
 }
 import { isJustReading, jevGuard, judgeCommand } from './jevguard.js';
 import { loadProviders } from './providers.js';
-import { cardWorkOnBase, currentBranch, ensureWorktree, finishRefusalStands, freeDiskBytes, headOf, leadGaveItBack, useGitHubToken, sweepWorktrees, releaseSharedPushGuard, existingWorktree, produced, releaseWorktree, tooEarlyToFinish, uncommittedCount, worktreeBrief } from './worktree.js';
-import { askingForComponent, checkouts, repoIdentity, resolveCheckout, voteByCode, workspaceBrief, describeCheckout } from './workspace.js';
+import { runGit, currentBranch, ensureWorktree, freeDiskBytes, useGitHubToken, sweepWorktrees, sweepCardFolders, releaseSharedPushGuard, existingWorktree, produced, releaseWorktree, uncommittedCount, worktreeBrief } from './worktree.js';
+import { askingForComponent, checkouts, fromCardApi, repoIdentity, resolveCheckout, voteByCode, workspaceBrief, describeCheckout } from './workspace.js';
 import { chooseRepoWithJev } from './jev.js';
 import { ROUTE, intake, intakeText, unclearBrief } from './intake.js';
 import { standingBrief } from './agent.js';
 import { startUi } from './ui.js';
 import { checkAndStage, harnessVersion, installedSdkVersion, pendingUpdate, updatesEnabled } from './updater.js';
-import { isCheckout, newerHarness, readyOnDisk, restartDecision, updateSelf } from './self-update.js';
 import { cloneBoardRepos, isEmptyFolder, parseBoardRepos } from './bootstrap-repo.js';
 import { updateSidecarSdk } from './updater-python.js';
 import { managedPython, usingManagedPython } from './engine-antigravity.js';
@@ -69,8 +67,27 @@ import { mergeableComments, combineComments, unparkReason, isBossInstruction, is
 import { LogShipper } from './log-ship.js';
 import { isOwnMove } from './own-moves.js';
 import { baseBranchesFromComponent } from './workspace.js';
-import { isAfterReleaseMove, isReleasedClose } from './flaredeck-proxy.js';
 import { canPublish, canPushTo } from './githubauth.js';
+import { createRestarter } from './harness/restarter.js';
+import { createPause } from './harness/pause.js';
+import { mountTools } from './harness/tools.js';
+import { installStartScripts, storedStartScript } from './harness/start-scripts.js';
+import { createServices, envName, serviceDir } from './features/services.js';
+import { repoNotes } from './harness/repo-notes.js';
+import { companionRepos, folderBrief, folderOf, openCardFolder, releaseCardFolder, startCompanions, withCompanions, writeFolderScript } from './features/card-folder.js';
+import { planUsage, RetryOnAnotherPlan } from './harness/plan-usage.js';
+import { createDispatch, isFreeWorkerMessage } from './features/dispatch.js';
+import { finishGate, handBackMemory } from './features/hand-back.js';
+import { requestSignIn } from './features/sign-in-request.js';
+import { managePane } from './features/manage-pane.js';
+import { createChat } from './features/chat.js';
+import { flaredeckReleaseDeps } from './features/release-wiring.js';
+import { onlyLooks, noteHandoverTool, handoverNeeded, cardWentElsewhere, handoverSubscription } from './harness/handover.js';
+import { parkLabel, LEAD_SWEEP_GOAL, MANAGER_BRIEF, MANAGER_SWEEP_BRIEF, LEAD_WITHOUT_CODE_BRIEF, READ_ONLY_BRIEF, waitedNote, isLeadDispatch, prompt, roleBriefs } from './harness/prompt.js';
+import { nothingOutstanding, RESUME_COOLDOWN_MS, workedRecently, unownedCards, isBookkeeping, forSomeoneElse, moveIsStale, workingLabel } from './harness/events.js';
+export { nothingOutstanding, RESUME_COOLDOWN_MS, workedRecently, unownedCards, isBookkeeping, forSomeoneElse, moveIsStale, workingLabel };
+export { parkLabel, LEAD_SWEEP_GOAL, MANAGER_BRIEF, MANAGER_SWEEP_BRIEF, LEAD_WITHOUT_CODE_BRIEF, READ_ONLY_BRIEF, waitedNote, isLeadDispatch, prompt };
+export { onlyLooks, noteHandoverTool, handoverNeeded, cardWentElsewhere, handoverSubscription };
 /**
  * The always-on agent.
  *
@@ -94,61 +111,6 @@ const HEARTBEAT_MS = 5 * 60 * 1000;
  * hours. Releasing loses nothing: a card that comes back is checked out again from what it pushed,
  * for the price of one install.
  */
-/** Minutes before trying a failed harness install again: 10 min, 30 min, 2h, then every 6h. */
-const INSTALL_BACKOFF_MIN = [10, 30, 120, 360];
-/**
- * Whether a get-outstanding answer says there is nothing at all: no cards and no unactioned
- * comments, and nothing hidden by a filter. Anything else, including an answer that could not be
- * read, means the sweep turn runs as before.
- */
-export function nothingOutstanding(text) {
-    if (!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;
-}
-/**
- * Whether a worker's card has gone to someone else, so its notes are no longer the worker's to
- * write. FlareDeck refuses them (set-card-notes: "not assigned to you"), and the handover turn
- * reopened a whole session only to be told so — CASE on HR-1128, TARS on HR-1141 (20 Oct).
- * Unknown (no card, no assignee, no id) is not "someone else": the handover runs as before.
- */
-export function cardWentElsewhere(card, selfId) {
-    const holder = card?.assigned_to?.uid;
-    return !!selfId && !!holder && holder !== selfId;
-}
-/** 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. */
-export function workedRecently(last, ids, now) {
-    return ids.some((id) => !!id && now - (last.get(id) ?? 0) < RESUME_COOLDOWN_MS);
-}
 export const WORKTREE_IDLE_MS = 2 * 60 * 60 * 1000;
 /** How often a running agent clears them. It used to happen only at startup, and agents run for days. */
 export const WORKTREE_SWEEP_EVERY_MS = 60 * 60 * 1000;
@@ -169,6 +131,23 @@ const waitingSince = new Map();
  */
 const AGENT_LOG_MAX = 5 * 1024 * 1024;
 let agentLogPath = join(configDir(), 'agent.log');
+/**
+ * Whether an event is work on the agent's own card (a worker's turn) rather than its person's chat.
+ * Its own sweeps and pickups count, and so does a card it parked coming back: a check-back it asked
+ * for, or a script a person approved (`run-answered`). Those carry the card but not its assignee, and
+ * read as chat they skipped the card's repository — FRIDAY, woken on HRG-0006 to check the website it
+ * had just released, looked only in its own HR Goat folder and flagged the card "not on the machine
+ * working it" (28 Oct).
+ */
+export function isOwnCardWork(e, selfId) {
+    if (e.event === 'sweep' && e.id === 'sweep')
+        return true;
+    if (String(e.id ?? '').startsWith('resume-'))
+        return true;
+    if (!(e.cardKey || e.cardCode))
+        return false;
+    return e.event === 'run-answered' || (!!selfId && e.assigneeKey === selfId) || (e.event === 'assigned' && e.forYou === true);
+}
 /** Which agent's file this process writes — set once serve() knows who it is. */
 export function agentLogFor(agent) {
     const slug = agent.toLowerCase().replace(/[^a-z0-9.]+/g, '-').replace(/^-+|-+$/g, '') || 'agent';
@@ -225,7 +204,6 @@ export async function serve(opts) {
      * MAX_PLAN_SWITCHES as a backstop.
      */
     const failedPlans = new Map();
-    const MAX_PLAN_SWITCHES = 4;
     const stream = new EventStream(opts.baseUrl, opts.auth);
     const state = {
         version: harnessVersion(),
@@ -450,10 +428,14 @@ export async function serve(opts) {
         if (await releaseSharedPushGuard(c.path).catch(() => false))
             log('tool', `restored push on ${c.path} (a worktree's push guard had leaked into it)`);
     }
+    /** Where card folders can be: beside a checkout in this folder, beside this folder, among the cloned ones. */
+    const cardFolderRoots = () => [...new Set([config.repo, dirname(config.repo), cardReposRoot()])];
     // Worktrees left by earlier cards — see sweepWorktrees. In the background: nothing waits on it.
     void (async () => {
         for (const c of [{ path: config.repo }, ...inScope])
             await sweepWorktrees(c.path, WORKTREE_IDLE_MS, (t) => log('tool', t)).catch(() => { });
+        for (const r of cardFolderRoots())
+            await sweepCardFolders(r, WORKTREE_IDLE_MS, (t) => log('tool', t)).catch(() => { });
     })();
     // Inside tmux, the history this pane prints is only reachable with tmux's mouse mode on.
     void ensureTmuxScrollback((t) => log('tool', t)).catch(() => { });
@@ -561,6 +543,8 @@ export async function serve(opts) {
                 if (now !== was && config.trustedScripts.length)
                     log('tool', `trusted scripts: ${config.trustedScripts.map((t) => t.name).join(', ')}`);
             }
+            // Start scripts kept in FlareDeck for the workspace's repositories (harness/start-scripts.ts).
+            config.startScripts = installStartScripts(hydrated.startScripts ?? [], join(configDir(), 'start-scripts'));
             // Skills shared from FlareDeck, kept current the same way. See skills.ts.
             const { flaredeckSkills, syncSkills } = await import('./skills.js');
             const plugin = await syncSkills(join(configDir(), 'skills', slug(config.repo)), flaredeckSkills(config.mcpUrl, tenantForMcp, () => opts.auth(), (config.boards ?? []).map((b) => b.key)), (t, warn) => log(warn ? 'warn' : 'tool', t));
@@ -726,42 +710,6 @@ export async function serve(opts) {
             `your branch and your notes are as you left them. If it does not, say so and ask again ` +
             `rather than guessing.\n`);
     };
-    /**
-     * A worker saying it is free, recognised by the harness rather than left to the brief.
-     *
-     * The message is one the harness writes, so its shape is known and matching it is not
-     * guesswork. It is turned into an instruction on the turn it arrives, because a standing rule
-     * in a brief is read once at the start of a long session and is exactly the kind of thing that
-     * gets skimmed past — and the cost of skimming this one is a worker sitting idle beside a full
-     * backlog, which is the thing the message exists to prevent.
-     */
-    const FREE_WORKER = /(^|\s)(Done with [A-Z][A-Z0-9]*-\d+\.|I am free — nothing queued, nothing running\.)\s*What is next\?/;
-    const freeWorkerBrief = (event) => {
-        if (!isLead)
-            return '';
-        if (event.event !== 'message' && event.event !== 'mentioned')
-            return '';
-        if (!FREE_WORKER.test(`${event.message ?? ''} ${event.line ?? ''}`))
-            return '';
-        const who = event.actor || 'A worker';
-        return (`\n\n## ${who} has nothing to do\n\n` +
-            `That message is the harness telling you this agent's queue is empty and nothing is running ` +
-            `on its machine. It is not a status update and it does not need a reply — it needs a card.\n\n` +
-            `Find it work now, before anything else in this turn:\n` +
-            `  · \`get-portfolio\` with state "todo" — for you it lists the board's "Start work here" lanes ` +
-            `AND your pool ("Lead picks from here", usually the Backlog). Your pool is yours to distribute: ` +
-            `move a card from it into a "Start work here" lane, or assign it, by who is free. Workers can also ` +
-            `pull from "Start work here" themselves. Never move a card out of any OTHER not-started lane ` +
-            `(Discovery, a plain Backlog, anything hidden) — what leaves those is a person's decision. A board ` +
-            `with neither kind of lane has no lane strategy yet: start nothing there, and tell your human.\n` +
-            `  · \`list_agents\` for what the rest of the team already holds, so you hand it something ` +
-            `nobody else is part-way through.\n` +
-            `  · Pick something it can actually run: a repository it has, on a machine you believe is ` +
-            `working.\n` +
-            `  · Assign it with \`assign-card\`. That is what wakes it.\n\n` +
-            `If there is genuinely nothing for it, say so in one line and leave it idle. That is a real ` +
-            `answer.\n`);
-    };
     const park = (cardKey, why) => {
         if (!cardKey)
             return;
@@ -792,7 +740,7 @@ export async function serve(opts) {
             // Until this agent knows who it is (the team read failed), nothing is hidden.
             const ours = (a) => !selfId
                 || a.sender_key === selfId
-                || (isLead && (a.review?.by === selfId || (!!a.sender_key && teamIds.has(a.sender_key))));
+                || (profile.dispatch && (a.review?.by === selfId || (!!a.sender_key && teamIds.has(a.sender_key))));
             const mine = all.filter((a) => a.tool_name === SCRIPT_REQUEST && ours(a));
             state.approvals = mine.map((a) => {
                 const lines = (a.input_preview || '').split('\n');
@@ -924,14 +872,14 @@ export async function serve(opts) {
     const runsSet = opts.deck
         ? runTools(config.runs ?? {}, () => onCard, opts.deck, (t) => log('tool', t), {
             attach: (card, path, comment) => attachFile(card, path, comment),
-            sendFile: (path, to, message) => sendFile(onCard?.cwd ?? config.repo, path, to || person?.uid || '', message),
+            sendFile: (path, to, message) => sendFile(onCard?.cwd ?? config.repo, path, to || chat.person()?.uid || '', message),
             flag: async (reason, kind, ask, flagOpts) => {
                 const cur = onCard;
                 if (!cur)
                     return null;
                 // A question, from a manager, with its person at this pane: ask FlareDeck to keep it off
                 // their phone. FlareDeck decides whether it is theirs; a script request is never held.
-                const hold = isManager && !!ask && presence.mode() === 'local';
+                const hold = profile.manage && !!ask && presence.mode() === 'local';
                 return flagCard({ card: cur.card, board: cur.board, code: cur.code }, reason, kind, ask, undefined, hold, flagOpts?.quiet);
             },
             unflag: async (cur) => {
@@ -1040,10 +988,8 @@ export async function serve(opts) {
     let leadId = null;
     let leadName = '';
     const bosses = new Set();
-    /** A lead's surface is wider than a worker's, so the tool list is too. */
-    let isLead = false;
-    /** A manager: above the leads, with no lead of its own. See MANAGER_BRIEF. */
-    let isManager = false;
+    /** What kind of agent this is: which features are on. Set from the team read; see profile.ts. */
+    let profile = PROFILES.worker;
     /**
      * A worker with nobody above it — no lead and no manager — is its own lead for releasing: it
      * merges and promotes its own cards wherever the board says "released by the lead". C3PO, a solo
@@ -1070,23 +1016,18 @@ export async function serve(opts) {
      * from a person. Card work is a worker's turn (its own checkout where the board has code); its
      * person's chat stays one conversation. Releasing is separate: only where a board names it.
      */
-    const assistantCard = (e) => isAssistant && (
-    // Its own sweep and its own pickups are card work too: worker turns, not the chat.
-    (e.event === 'sweep' && e.id === 'sweep')
-        || String(e.id ?? '').startsWith('resume-')
-        || (!!(e.cardKey || e.cardCode) && (e.assigneeKey === selfId || (e.event === 'assigned' && e.forYou === true))));
-    /**
-     * 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.
-     */
-    let isAssistant = false;
-    let person = null;
-    /** An assistant's running turn, as its person watches it in FlareDeck chat. See LiveFeed. */
-    let liveFeed = null;
+    const assistantCard = (e) => profile.chat && isOwnCardWork(e, selfId);
     const assistantSessionFile = join(configDir(), 'assistant-sessions', `${slug(`${opts.agent ?? 'agent'}-${config.repo}`)}.json`);
+    /** The conversation with the person it works for (the `chat` feature): see features/chat.ts. */
+    const chat = createChat({
+        kind: () => (profile.kind === 'general' ? 'general' : 'assistant'), mcpUrl: config.mcpUrl, auth: () => opts.auth(), repo: config.repo, sessionFile: assistantSessionFile,
+        agent: (opts.agent ?? 'your assistant').replace(/\s*\(.*$/, ''),
+        send: async (to, message) => { await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'send-message', { to, message }); },
+        log,
+    });
     /** The mode and the held questions, as the pane draws them. */
     const showPresence = () => {
-        if (!isManager) {
+        if (!profile.manage) {
             delete state.presence;
             delete state.asks;
             return;
@@ -1095,11 +1036,9 @@ export async function serve(opts) {
         const until = presence.deadline();
         state.asks = presence.held().map((a) => ({ card: a.code || a.card, question: a.question, options: a.options, person: a.person, ...(until ? { until } : {}) }));
     };
-    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();
+    const keepTool = (name) => offeredTo(profile.tools, name);
+    /** Cards handed to the lead for review, and the branch head then. See features/hand-back.ts. */
+    const handedBack = handBackMemory();
     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.
@@ -1130,25 +1069,15 @@ export async function serve(opts) {
                 bosses.add(a.name.trim().toLowerCase());
         if (leadId)
             log('tool', `your lead is ${leadName} — ${leadName} verifies your work before it goes anywhere`);
-        isLead = team.you.role === 'lead';
-        // The role exists in FlareDeck before the harness has a manager mode (docs/spec-manager-role.md
-        // §14). Said plainly, so nobody reads a manager account running here as a manager at work.
-        isManager = team.you.role === 'manager';
-        isAssistant = team.you.role === 'assistant';
-        if (isAssistant) {
+        profile = profileFor(team.you.role);
+        if (profile.chat) {
             state.waitingFor = undefined;
-            const tenant = tenantFromToken(await opts.auth());
-            person = tenant ? await assistantPerson(config.mcpUrl, tenant, () => opts.auth()) : null;
-            liveFeed = tenant && person ? new LiveFeed(liveSender(config.mcpUrl, tenant, () => opts.auth())) : null;
-            const kept = loadAssistantSession(assistantSessionFile);
-            if (person)
-                state.waitingFor = person.name;
-            log('event', person
-                ? `You are ${person.name}'s assistant — you listen to them in FlareDeck chat, and to whoever types here${kept ? ', carrying on your conversation from before' : ''}.`
-                : 'You are an assistant, but nobody is set as the person you work for — set "Works for" on this agent in FlareDeck. Until then nothing reaches you.');
+            await chat.start(tenantFromToken(await opts.auth()));
+            if (chat.person())
+                state.waitingFor = chat.person().name;
         }
         showPresence();
-        if (isManager) {
+        if (profile.manage) {
             log('event', 'You are a manager here — list-agents shows the teams that report to you and the machines they run on; machine-exec reaches those machines.');
             log('event', 'Your team\'s technical, access and information questions come to you first; what you cannot settle goes to the person the board names.');
             log('event', 'At this pane? Type /local and questions for you are shown here instead of on your phone (back to /remote after ten minutes unanswered).');
@@ -1167,9 +1096,8 @@ export async function serve(opts) {
                 if (soloWorker)
                     log('tool', 'nobody is above you, so you release your own cards where the board says "released by the lead"');
                 releaseSet = releaseTools({
-                    role: () => (isManager ? 'manager' : isLead || soloWorker ? 'lead' : isAssistant ? 'assistant' : 'worker'),
+                    role: () => releaseRole(profile, soloWorker),
                     boards: () => config.boards ?? [],
-                    ladder: (boardId) => fetchLadder(config.mcpUrl, tenant, boardId, () => opts.auth()),
                     job: () => (job ? { branch: job.branch, cwd: job.cwd, card: onCard?.card ?? job.card, ...(onCard?.code ? { code: onCard.code } : {}), ...(onCard?.board ? { board: onCard.board } : {}) } : null),
                     token: async () => {
                         if (flaredeckGithub) {
@@ -1180,48 +1108,10 @@ export async function serve(opts) {
                         throw new Error('FlareDeck has no GitHub connection to release with — connect GitHub on Integrations.');
                     },
                     root: join(configDir(), 'release'),
-                    approve: async (card, who, what) => {
-                        const approvers = [who === 'person' ? self.person : self.manager].filter((x) => !!x);
-                        if (!approvers.length)
-                            return { allow: false, reason: `nobody is set as your ${who === 'person' ? 'person (Works for / reports to)' : 'manager'} in FlareDeck to approve it` };
-                        const ask = flaredeckDecider(deck, card, 60 * 60_000, { approvers });
-                        const v = await ask({ toolName: 'release', input: what }, { signal: new AbortController().signal });
-                        return v.allow ? { allow: true } : { allow: false, reason: v.reason };
-                    },
-                    originOf: (cwd) => new Promise((res) => {
-                        const c = spawn('git', ['remote', 'get-url', 'origin'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
-                        let out = '';
-                        c.stdout.on('data', (d) => (out += String(d)));
-                        c.on('close', () => res(out.trim()));
-                        c.on('error', () => res(''));
-                    }),
                     log: (t) => log('tool', t),
                     self: () => selfId ?? '',
-                    cardInfo: async (code) => {
-                        const c = await deck.card(code).catch(() => null);
-                        if (!c)
-                            return null;
-                        const since = c.release_since ? Date.parse(String(c.release_since)) : NaN;
-                        return {
-                            laneType: c.lane?.type ?? null,
-                            minutesInReleaseLane: String(c.lane?.type || '').toLowerCase() === 'release' && Number.isFinite(since) ? (Date.now() - since) / 60_000 : null,
-                            releases: (Array.isArray(c.releases) ? c.releases : []).map((r) => ({ environment: String(r.environment ?? ''), sha: String(r.sha ?? '') })),
-                        };
-                    },
-                    record: async (card, text) => { await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'create-card-comment', { card_id: card, comment: text }); },
-                    recordReleased: async (o) => {
-                        const res = await fetch(`${new URL(config.mcpUrl).origin}/api/v1/${encodeURIComponent(tenant)}/cards/released`, {
-                            method: 'POST', headers: { authorization: `Bearer ${await opts.auth()}`, 'content-type': 'application/json' },
-                            body: JSON.stringify(o), signal: AbortSignal.timeout(20_000),
-                        });
-                        return res.ok ? (await res.json()) : null;
-                    },
-                    watch: async (card) => {
-                        await fetch(`${new URL(config.mcpUrl).origin}/api/v1/${encodeURIComponent(tenant)}/deploy-watch`, {
-                            method: 'POST', headers: { authorization: `Bearer ${await opts.auth()}`, 'content-type': 'application/json' },
-                            body: JSON.stringify({ card_key: card }), signal: AbortSignal.timeout(15_000),
-                        });
-                    },
+                    // The ladder, approvals, card state and release records, from FlareDeck: see features/release-wiring.ts.
+                    ...flaredeckReleaseDeps({ mcpUrl: config.mcpUrl, tenant, auth: () => opts.auth(), deck, approvers: self }),
                 });
             }
         }
@@ -1264,28 +1154,6 @@ export async function serve(opts) {
      * Polled rather than pushed, because nothing streams another agent's status — and slowly,
      * since agents check in every five minutes, so a faster poll would show the same row again.
      */
-    /**
-     * An idle worker is the lead's problem, and the lead already knows within a minute.
-     *
-     * It polls its team every sixty seconds to draw the pane, so "CASE idle 4m ago" is sitting on
-     * its screen — and it did nothing with it. Dispatch waited for the hourly sweep, or for the
-     * worker to say it was free, which for a while it never did. Eleven cards waited in Ready For
-     * Dev while two agents sat idle and the lead reported "waiting for work".
-     *
-     * The poll is already happening, so noticing costs nothing. Rate-limited because an idle
-     * worker with genuinely nothing to give it stays idle, and a lead asked about it every minute
-     * learns to say "nothing" without looking.
-     */
-    const DISPATCH_AGAIN_MS = 10 * 60 * 1000;
-    let lastDispatch = 0;
-    const workersAreIdle = (team) => 
-    // Not 'never-seen': a member that has never connected (FRIDAY is a person's own session) is
-    // not a free worker, and counting one kept the team permanently "idle".
-    myTeam(team).mine.filter((a) => !a.card && a.state !== 'stopped' && a.state !== 'never-seen' && !a.stale).map((a) => a.name);
-    let lastDispatchKey = '';
-    /** The ready cards the lead was last woken to look at for a free worker. See drain(). */
-    let lastFreeLook = { key: '', at: 0 };
-    let lastSkipWhy = '';
     /**
      * What is ready to hand over, read in code — no model turn to find out it is nothing. Unreadable
      * gives ['?'], so callers wake as before: a missed dispatch is worse than a spare turn.
@@ -1298,31 +1166,17 @@ export async function serve(opts) {
         const text = out === null ? null : typeof out === 'string' ? out : JSON.stringify(out);
         return text === null ? ['?'] : unownedCards(text);
     };
+    // The `dispatch` feature: whether a free worker is worth waking the lead for. See features/dispatch.ts.
+    const dispatch = createDispatch({ ready: readyToHand, log });
     if (leadOfTeam) {
         const teamTimer = setInterval(() => {
             void (async () => {
                 try {
                     const team = await fetchTeam(opts.baseUrl, await opts.auth());
                     showTeam(team);
-                    const free = workersAreIdle(team);
-                    if (free.length && !working && !queue.length && Date.now() - lastDispatch > DISPATCH_AGAIN_MS) {
-                        lastDispatch = Date.now();
-                        const ready = await readyToHand();
-                        const d = dispatchDecision(lastDispatchKey, ready, free);
-                        if (!d.wake) {
-                            if (d.why !== lastSkipWhy)
-                                log('tool', `${free.join(', ')} idle — not waking the lead: ${d.why}`);
-                            lastSkipWhy = d.why;
-                            lastDispatchKey = d.key;
-                        }
-                        else {
-                            lastDispatchKey = d.key;
-                            lastSkipWhy = '';
-                            log('event', `${free.join(', ')} ${free.length === 1 ? 'is' : 'are'} idle — looking for work to hand over`);
-                            if (enqueue({ id: `dispatch-${Date.now()}`, event: 'sweep', line: `${free.join(', ')} have nothing to do` }))
-                                void drain();
-                        }
-                    }
+                    const wake = await dispatch.onTeam(team, working || queue.length > 0);
+                    if (wake && enqueue({ id: `dispatch-${Date.now()}`, event: 'sweep', line: wake }))
+                        void drain();
                 }
                 catch {
                     // A team the lead briefly cannot see is not worth a line in the log every minute; the
@@ -1368,6 +1222,8 @@ export async function serve(opts) {
             for (const c of [{ path: config.repo }, ...inScope]) {
                 await sweepWorktrees(c.path, WORKTREE_IDLE_MS, (t) => log('tool', t), activeTrees()).catch(() => { });
             }
+            for (const r of cardFolderRoots())
+                await sweepCardFolders(r, WORKTREE_IDLE_MS, (t) => log('tool', t), activeTrees()).catch(() => { });
         })();
     }, WORKTREE_SWEEP_EVERY_MS);
     worktreeTimer.unref();
@@ -1378,12 +1234,6 @@ export async function serve(opts) {
     setTimeout(sweepTemp, 5 * 60 * 1000).unref();
     const scratchTimer = setInterval(sweepTemp, SCRATCH_SWEEP_EVERY_MS);
     scratchTimer.unref();
-    /**
-     * Paused: a wall this agent cannot get past by itself, so it does no work at all — no turns,
-     * no tokens — until its lead resumes it. See flaredeck-mcp/src/mcp/pause.ts for the why.
-     */
-    let paused = null;
-    let readyReported = false;
     /** Repositories already reported as unpublishable, so each is said once. */
     const warnedRepos = new Set();
     /** Walls the agent cannot climb, checked in code — never by asking the model. */
@@ -1434,6 +1284,8 @@ export async function serve(opts) {
         const free = freeDiskBytes(config.repo);
         if (free !== null && free < DISK_MIN) {
             await sweepWorktrees(config.repo, WORKTREE_IDLE_LOW_DISK_MS, (t) => log('tool', t), activeTrees()).catch(() => { });
+            for (const r of cardFolderRoots())
+                await sweepCardFolders(r, WORKTREE_IDLE_LOW_DISK_MS, (t) => log('tool', t), activeTrees()).catch(() => { });
             const after = freeDiskBytes(config.repo);
             if (after !== null && after < DISK_MIN) {
                 return { check: 'disk', reason: `This machine has only ${(after / 1e9).toFixed(1)} GB of disk free, and builds, Docker and test environments all fail when it fills. Idle worktrees are already cleared; free space (Docker images, caches, old checkouts).` };
@@ -1441,103 +1293,28 @@ export async function serve(opts) {
         }
         return null;
     };
-    const enterPause = async (wall) => {
-        if (paused?.check === wall.check)
-            return;
-        paused = wall;
-        readyReported = false;
-        state.paused = wall.reason;
-        log('warn', `PAUSED (${wall.check}): ${wall.reason}`);
-        void liveRun?.stop().catch(() => { });
-        try {
-            const r = await opts.deck?.pause(wall.check, wall.reason);
-            /* A solo agent has no lead: its cards stay with it (each gets a comment) and nobody is
-               messaged. Saying "told the lead, handed back …" then described something that never
-               happened. */
-            if (r && !r.already) {
-                log('event', r.lead
-                    ? `told the lead${r.handedBack.length ? `, handed back ${r.handedBack.join(', ')}` : ''} — doing nothing until resumed`
-                    : `no lead to tell — ${r.handedBack.length ? `left a note on ${r.handedBack.join(', ')}; they stay mine` : 'nothing handed back'}. ${wall.check === 'disk' ? 'I resume myself once the disk is clear.' : wall.check === 'mcp' ? 'I resume myself once it is connected.' : 'A person resumes me.'}`);
-            }
-        }
-        catch (e) {
-            log('warn', `could not tell FlareDeck I am paused: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    };
-    // While paused: ask FlareDeck every minute whether the lead has resumed this agent (one REST
-    // call, no model), and re-check the wall every ten, saying once when it is gone.
-    let lastWallCheck = 0;
-    const pauseTick = setInterval(() => {
-        if (!paused)
-            return;
-        void (async () => {
-            const server = await opts.deck?.pauseState().catch(() => undefined);
-            if (server === null) {
-                const still = await walls();
-                if (still) {
-                    paused = null;
-                    await enterPause(still);
-                    return;
-                }
-                log('event', `resumed by the lead — back to work`);
-                paused = null;
-                state.paused = undefined;
-                void resumeOwnWork();
-                return;
-            }
-            /* Disk is a statfs call, so it is checked every tick; the others ask GitHub, so every ten
-               minutes. A disk wall that has cleared resumes the agent at once — there is nothing for a
-               lead to decide about a number, and waiting for one left the agent idle for hours after
-               the space had already been freed. */
-            const selfClearing = paused.check === 'disk' || paused.check === 'mcp';
-            if (selfClearing) {
-                let cleared = '';
-                if (paused.check === 'disk') {
-                    const free = freeDiskBytes(config.repo);
-                    if (free === null || free < DISK_MIN)
-                        return;
-                    cleared = `disk is clear (${(free / 1e9).toFixed(0)} GB free)`;
-                }
-                else {
-                    // One HTTP call a minute while paused; null (FlareDeck unreachable) is not "connected".
-                    const missing = await refreshMcp();
-                    if (missing === null || missing.length)
-                        return;
-                    cleared = 'the required MCP servers are connected';
-                }
-                const r = await opts.deck?.resumeSelf().catch(() => null);
-                if (r?.resumed) {
-                    log('event', `${cleared} — resumed myself and told the lead`);
-                    paused = null;
-                    state.paused = undefined;
-                    readyReported = false;
-                    void resumeOwnWork();
-                    return;
-                }
-                // An older server without self-resume: fall through to telling the lead, as before.
-            }
-            if ((!selfClearing && Date.now() - lastWallCheck < 10 * 60 * 1000) || readyReported)
-                return;
-            lastWallCheck = Date.now();
-            if (!(await walls())) {
-                // No lead to resume it (a solo agent, an assistant): it resumes itself, as for disk.
-                if (!leadId) {
-                    const r = await opts.deck?.resumeSelf().catch(() => null);
-                    if (r?.resumed) {
-                        log('event', `${paused.check} is fixed — resumed myself (no lead to ask)`);
-                        paused = null;
-                        state.paused = undefined;
-                        readyReported = false;
-                        void resumeOwnWork();
-                        return;
-                    }
-                }
-                readyReported = true;
-                log('event', `${paused.check} is fixed — told the lead; waiting to be resumed`);
-                await opts.deck?.ready().catch(() => { });
+    // Paused on a wall it cannot get past by itself: see harness/pause.ts.
+    const pause = createPause({
+        record: opts.deck,
+        walls,
+        cleared: async (check) => {
+            if (check === 'disk') {
+                const free = freeDiskBytes(config.repo);
+                return free === null || free < DISK_MIN ? null : `disk is clear (${(free / 1e9).toFixed(0)} GB free)`;
             }
-        })();
-    }, 60 * 1000);
+            // One HTTP call a minute while paused; null (FlareDeck unreachable) is not "connected".
+            const missing = await refreshMcp();
+            return missing === null || missing.length ? null : 'the required MCP servers are connected';
+        },
+        hasLead: () => !!leadId,
+        stopRun: () => void liveRun?.stop().catch(() => { }),
+        show: (reason) => { state.paused = reason; },
+        // Declared further down; by the time a pause clears, it is.
+        resume: () => setTimeout(() => void resumeOwnWork(), 0),
+        log,
+    });
+    const enterPause = pause.enter;
+    const pauseTick = setInterval(() => void pause.tick(), 60 * 1000);
     pauseTick.unref?.();
     /**
      * This turn's browser, so it can be closed when the turn ends.
@@ -1640,6 +1417,76 @@ export async function serve(opts) {
     const idleStops = new Map();
     /** Environments this process started and has not stopped, by checkout — reused by later turns. */
     const envUp = new Map();
+    /** How each of those was started, so it is stopped with the same script (a stored one has no file in the checkout). */
+    const envHow = new Map();
+    const stopEnv = (p) => { const h = envHow.get(p); envHow.delete(p); return stopEnvironment(p, h?.declared, h?.stored); };
+    /** The checkouts in the same card folder as `p` (itself included) — one card's environment. */
+    const sameCard = (a, b) => a === b || (!!folderOf(a) && folderOf(a) === folderOf(b));
+    /** What a card folder's other repositories said when they came up, for a turn that reuses them. */
+    const companionNotes = new Map();
+    /** What cards need running beside them, shared between cards (features/services.ts). */
+    const services = createServices({
+        root: join(configDir(), 'services'),
+        git: (args, cwd) => runGit(args, cwd),
+        token: async () => { if (flaredeckGithub)
+            await refreshMcp(); return flaredeckGithub?.token ?? null; },
+        storedScript: (repository) => storedStartScript(config.startScripts, repository),
+        start: startEnvironment,
+        stop: stopEnvironment,
+        log,
+    });
+    /** Keep a start script in FlareDeck for a repository (Integrations → Repositories). */
+    const saveStartScriptFor = async (repository, script) => {
+        const tid = tenantFromToken(await opts.auth());
+        const id = repoIdentity(repository).split('/').slice(-2).map(encodeURIComponent).join('/');
+        const r = await fetch(`${new URL(config.mcpUrl).origin}/api/v1/${encodeURIComponent(tid ?? '')}/repositories/${id}/start`, {
+            method: 'PUT', headers: { authorization: `Bearer ${await opts.auth()}`, 'content-type': 'application/json' },
+            body: JSON.stringify({ script }), signal: AbortSignal.timeout(20_000),
+        });
+        const body = await r.json().catch(() => ({}));
+        return r.ok ? { ok: true } : { ok: false, message: body.message ?? `HTTP ${r.status}` };
+    };
+    /** …and use it on this machine at once, rather than from the next time FlareDeck's list is read. */
+    const keepStartScript = (repository, script) => {
+        const dir = join(configDir(), 'start-scripts');
+        const path = join(dir, `${repoIdentity(repository).replace(/\//g, '__').replace(/[^\w.-]/g, '_')}.sh`);
+        try {
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(path, script, { mode: 0o755 });
+            config.startScripts = { ...(config.startScripts ?? {}), [repoIdentity(repository)]: path };
+            return path;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Bring up a card folder's other repositories, each from its worktree, and keep track of them. */
+    const startFolder = async (cs, environment) => {
+        const r = await startCompanions(cs, environment, { start: startEnvironment, storedScript: (repo) => storedStartScript(config.startScripts, repo), log: (t) => log('tool', t) });
+        for (const c of cs) {
+            const st = r.started.get(c.path);
+            if (!st)
+                continue;
+            const stored = storedStartScript(config.startScripts, c.repository);
+            envUp.set(c.path, st);
+            envHow.set(c.path, { ...(c.script ? { declared: c.script } : {}), ...(stored ? { stored } : {}) });
+        }
+        for (const n of r.notes)
+            log('tool', `folder: ${n}`);
+        return { env: r.env, notes: r.notes };
+    };
+    /** A clone to cut a card folder's worktree from: a checkout here first, else one cloned for it. */
+    const sourceFor = async (repository) => {
+        const id = repoIdentity(repository);
+        for (const root of [config.repo, cardReposRoot()]) {
+            const hit = (await checkouts(root).catch(() => [])).find((c) => c.origin && repoIdentity(c.origin) === id);
+            if (hit)
+                return hit.path;
+        }
+        return services.clone(repository);
+    };
+    const servicesTimer = setInterval(() => void services.stopIdle(), 15 * 60_000);
+    servicesTimer.unref();
     const ENV_IDLE_MS = 20 * 60_000;
     /**
      * Checkouts with a sign-in still waiting for a person, and since when. Their environment is
@@ -1657,7 +1504,8 @@ export async function serve(opts) {
      */
     const stopOtherEnvironments = async (cwd) => {
         for (const other of [...envUp.keys()]) {
-            if (other === cwd)
+            // The card's own folder is one environment: its API and CMS are what its site is using.
+            if (sameCard(other, cwd))
                 continue;
             const waiting = signInPending.get(other);
             if (waiting && Date.now() - waiting < SIGN_IN_HOLD_MS)
@@ -1668,7 +1516,7 @@ export async function serve(opts) {
                 idleStops.delete(other);
             }
             envUp.delete(other);
-            const ok = await stopEnvironment(other).catch(() => false);
+            const ok = await stopEnv(other).catch(() => false);
             if (ok)
                 log('tool', `environment stopped in ${other.split('/').pop()} — another card's, and this card needs its ports`);
         }
@@ -1687,8 +1535,13 @@ export async function serve(opts) {
                 scheduleEnvironmentStop(cwd);
                 return;
             }
+            // The whole card folder comes down together: nothing else uses its API and CMS.
+            for (const p of [...envUp.keys()].filter((k) => k !== cwd && sameCard(k, cwd))) {
+                envUp.delete(p);
+                void stopEnv(p).catch(() => false);
+            }
             envUp.delete(cwd);
-            void stopEnvironment(cwd).then((ok) => { if (ok)
+            void stopEnv(cwd).then((ok) => { if (ok)
                 log('tool', `environment stopped in ${cwd.split('/').pop()} (idle 20m)`); }).catch(() => { });
         }, ENV_IDLE_MS));
         idleStops.get(cwd).unref?.();
@@ -1720,68 +1573,23 @@ export async function serve(opts) {
             });
         });
     };
-    /** Nobody answered here: the held question goes to the phone, as it stands on the card. */
-    const sendOn = async (a) => {
-        const label = a.code || a.card;
-        try {
-            const out = await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'set-needs-human', {
-                card_id: a.code || a.card, ...(a.board ? { board_id: a.board } : {}), push_held: true,
-            });
-            log('warn', `${label}: ${out.split('\n').find((l) => l.startsWith('**Told**'))?.replace(/\*\*/g, '') ?? out.split('\n')[0]}`);
-        }
-        catch (e) {
-            log('warn', `${label}: could not send the question on to ${a.person}'s phone (${e instanceof Error ? e.message : String(e)}) — it is still on the card`);
-        }
-    };
-    const setMode = (mode) => {
-        if (!isManager) {
-            log('warn', '/local and /remote are for a manager\'s pane: they decide where questions for the person the manager reports to are shown.');
-            return;
-        }
-        presence.set(mode);
-        if (mode === 'local') {
-            log('you', 'local — questions for you are shown here and kept off your phone. One left unanswered for ten minutes goes to your phone, and this goes back to remote.');
-        }
-        else {
-            const waiting = presence.release();
-            log('you', `remote — questions go to FlareDeck and your phone${waiting.length ? `, including the ${waiting.length} waiting here` : ''}.`);
-            for (const a of waiting)
-                void sendOn(a);
-        }
-        showPresence();
-    };
-    /**
-     * Answered at the pane. Written on the card first — an answer that exists only in a terminal is
-     * one nobody else can find — then the flag comes off and the card goes back to the agent.
-     */
-    const answerHeld = async (a, answer) => {
-        presence.take(a.card);
-        showPresence();
-        const label = a.code || a.card;
-        log('you', `${label}: ${answer}`);
-        const ref = { card_id: a.code || a.card, ...(a.board ? { board_id: a.board } : {}) };
-        try {
-            await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'create-card-comment', {
-                ...ref, comment: `**${a.person} answered at ${state.agent}'s pane.**\n\n> ${a.question}\n\n${answer}`,
-            });
-            await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'clear-needs-human', ref);
-        }
-        catch (e) {
-            log('warn', `${label}: the answer could not be written to the card (${e instanceof Error ? e.message : String(e)}) — the agent still gets it`);
-        }
-        parked.delete(a.card);
-        resumeParked({ card: a.card, ...(a.board ? { board: a.board } : {}), ...(a.code ? { code: a.code } : {}) }, `${a.person} answered your question at this pane.\n\nYou asked: ${a.question}\nThe answer: ${answer}\n\nIt is on the card as a comment and the flag is cleared. Carry on from where you stopped.`);
-    };
-    const presenceTimer = setInterval(() => {
-        const due = presence.expire();
-        if (due.length) {
-            log('warn', `nobody answered here in ten minutes — ${due.length === 1 ? 'that question has' : `${due.length} questions have`} gone to your phone, and this pane is remote again. /local when you are back.`);
-            for (const a of due)
-                void sendOn(a);
-        }
-        if (due.length || state.asks?.length)
-            showPresence();
-    }, 15_000);
+    // A manager's person answering at this pane: see features/manage-pane.ts.
+    const pane = managePane({
+        presence,
+        manages: () => profile.manage,
+        call: async (tool, args) => String(await callFlaredeckTool(config.mcpUrl, await opts.auth(), tool, args)),
+        resume: (a, text) => {
+            parked.delete(a.card);
+            resumeParked({ card: a.card, ...(a.board ? { board: a.board } : {}), ...(a.code ? { code: a.code } : {}) }, text);
+        },
+        show: showPresence,
+        agent: () => state.agent,
+        log,
+    });
+    const sendOn = pane.sendOn;
+    const setMode = pane.setMode;
+    const answerHeld = pane.answer;
+    const presenceTimer = setInterval(() => pane.tick(), 15_000);
     presenceTimer.unref();
     const steer = (text) => {
         // Mid sign-in, the next line is the redirect address — for the sign-in, never the agent.
@@ -1943,7 +1751,7 @@ export async function serve(opts) {
         if (pending.has(event.id))
             return false;
         // Workers only: a lead's or manager's sweep also finds cards nobody holds, and those send no event.
-        if (event.event === 'sweep' && !isLead && !isManager) {
+        if (event.event === 'sweep' && !profile.oversees) {
             if (sweptSinceLastEvent)
                 return false;
             sweptSinceLastEvent = true;
@@ -2012,12 +1820,21 @@ export async function serve(opts) {
     const prepareAhead = (event) => {
         if (!wantsIntake(event) || preparedAhead.has(event.id))
             return;
+        const label = event.cardCode || event.cardKey || '';
+        /* One read per CARD, not per event: a comment and an assignment on HR-1140 arriving together
+           each read the card, its Jam and its code, and each paid Jev (21 Oct). The second shares the
+           first's — it is the same card, read the same moment. */
+        const same = [...preparedAhead.entries()].find(([id, p]) => id !== event.id && p.card === (event.cardKey || event.cardCode) && Date.now() - p.at < PREPARED_FRESH_MS);
+        if (same) {
+            preparedAhead.set(event.id, same[1]);
+            return;
+        }
         if (preparing >= PREPARE_AHEAD_LIMIT)
             return;
-        const label = event.cardCode || event.cardKey || '';
         preparing++;
         preparedAhead.set(event.id, {
             at: Date.now(),
+            card: event.cardKey || event.cardCode,
             // The repo this card belongs to, so the code search behind the brief searches the right
             // project — at a workspace root there is no git to grep, and it would silently find nothing.
             promise: (async () => {
@@ -2119,46 +1936,10 @@ export async function serve(opts) {
             await measurePlan(subs, plan, true);
     };
     void measureAll();
-    // The walls, checked once at start — before any card is picked up. A restart while paused
-    // picks the pause back up from FlareDeck rather than re-announcing it.
-    void (async () => {
-        const server = await opts.deck?.pauseState().catch(() => undefined);
-        if (server) {
-            paused = { check: server.check, reason: server.reason };
-            readyReported = !!server.ready;
-            state.paused = server.reason;
-            log('warn', `PAUSED since ${server.since.slice(0, 16).replace('T', ' ')} (${server.check}) — doing nothing until the lead resumes me`);
-            /* Checked again now, not in ten minutes: a restart is often BECAUSE somebody fixed it. C3PO
-               came back up with GitHub access sorted and still sat paused, waiting for a lead it does
-               not have (16 Oct). Fixed and no lead: resume. Fixed with a lead: tell it, once. */
-            const still = await walls();
-            if (!still) {
-                lastWallCheck = Date.now();
-                if (!leadId) {
-                    const r = await opts.deck?.resumeSelf().catch(() => null);
-                    if (r?.resumed) {
-                        log('event', `${server.check} is fixed — resumed myself (no lead to ask)`);
-                        paused = null;
-                        state.paused = undefined;
-                        readyReported = false;
-                        setTimeout(() => void resumeOwnWork(), 0); // declared further down
-                        return;
-                    }
-                }
-                if (!readyReported) {
-                    readyReported = true;
-                    log('event', `${server.check} is fixed — told the lead; waiting to be resumed`);
-                    await opts.deck?.ready().catch(() => { });
-                }
-            }
-            return;
-        }
-        const wall = await walls();
-        if (wall)
-            await enterPause(wall);
-    })();
+    // The walls, checked once at start — before any card is picked up (harness/pause.ts).
+    void pause.start();
     const sweepNow = () => {
-        if (paused || !sweepsEnabled || stopping)
+        if (pause.paused() || !sweepsEnabled || stopping)
             return;
         // Busy is reason enough to wait: the next tick is minutes away and the work is not going
         // anywhere.
@@ -2187,7 +1968,7 @@ export async function serve(opts) {
             }
             if (working || queue.length || live.size)
                 return;
-            const only = isAssistant ? ' — only the cards people have given you; nothing from the pile, and anything else is your person\'s to direct' : '';
+            const only = profile.cards === 'from-people' ? ' — only the cards people have given you; nothing from the pile, and anything else is your person\'s to direct' : '';
             if (enqueue({ id: 'sweep', event: 'sweep', line: `checking what is still assigned to you${only}` }))
                 void drain();
         })();
@@ -2244,7 +2025,7 @@ export async function serve(opts) {
     const resumeOwnWork = async () => {
         /* 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)
+        if (pause.paused() || !sweepsEnabled || stopping || working || queue.length)
             return false;
         /* FlareDeck decides which card, never the model and never this file (Cobus, 16 Oct): its own
            card in progress first, then its own highest-priority card, then the pile — each by
@@ -2259,6 +2040,9 @@ export async function serve(opts) {
                 // 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.
                 ...(skipNow().length ? { skip: skipNow() } : {}),
+                // Only its own cards unless the profile takes from the pile. FlareDeck also refuses an
+                // assistant the pile by role; this says it for any kind of agent the harness runs.
+                ...(profile.pile ? {} : { pile: false }),
             }) ?? '');
         }
         catch {
@@ -2280,7 +2064,7 @@ export async function serve(opts) {
             return false;
         // A lead resumes its own card in progress and nothing else: a card on it in a start lane is its
         // to HAND OUT (16 Oct), and one from the pile is a worker's. JARVIS was about to be given HR-0580.
-        if ((isLead || isManager) && kind !== 'doing')
+        if (profile.oversees && kind !== 'doing')
             return false;
         if (kind === 'took') {
             // Assigned just now: FlareDeck's "assigned" event brings it here, as for any assignment.
@@ -2330,6 +2114,16 @@ export async function serve(opts) {
     // pkill is worse than one that occasionally abandons a turn — the events are unacknowledged,
     // so whatever it was doing comes back.
     let stopping = false;
+    // Into a newer harness while idle: see harness/restarter.ts.
+    const restarter = createRestarter({
+        log: (kind, text) => log(kind, text),
+        busy: () => ({ stopping, working, queued: queue.length, live: live.size }),
+        shutdown: () => shutdown(),
+        resume: () => void drain(),
+    });
+    const restartDue = restarter.due;
+    const maybeRestart = restarter.maybe;
+    restarter.start();
     const shutdown = () => {
         if (stopping) {
             say('stopping now');
@@ -2349,68 +2143,15 @@ export async function serve(opts) {
         clearInterval(sweepTimer);
         clearInterval(worktreeTimer);
         clearInterval(resumeTimer);
+        clearInterval(servicesTimer);
+        void services.stopAll();
         teamTimers.forEach(clearInterval);
         // Belt and braces: if unwinding wedges, do not hang forever pretending to shut down. Longer
         // when cards are still open, because their handovers run first and each is a short turn.
-        setTimeout(() => (restartTo && restarting ? relaunchSelf(restartTo) : process.exit(0)), live.size ? 120_000 : 8000).unref();
+        setTimeout(() => (restarter.relaunchTo() ? relaunchSelf(restarter.relaunchTo()) : process.exit(0)), live.size ? 120_000 : 8000).unref();
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
-    /*
-     * A newer harness, taken while idle. Startup already installs the newest version; a RUNNING
-     * agent never did, so every release meant restarting ten agents by hand. Now: when idle, look;
-     * when there is a newer version, stop the normal way (stream closed, FlareDeck told it stopped)
-     * and come back up in the same pane on the new one. Never mid-turn, never with work queued.
-     */
-    const runningVersion = harnessVersion();
-    let restartTo = '';
-    let readySince = 0;
-    let restarting = false;
-    let lookAgainAt = 0;
-    // LOOKING happens on the timer whether or not a turn is running — a busy agent never had an
-    // idle moment at the check, so it never even saw the new version (TARS). Acting waits for a gap.
-    const lookForNewer = async () => {
-        if (restartTo || !updatesEnabled() || !runningVersion || Date.now() < lookAgainAt)
-            return;
-        restartTo = await newerHarness(runningVersion);
-        if (!restartTo)
-            return;
-        readySince = Date.now();
-        log('tool', `harness ${restartTo} is ready — restarting into it between turns`);
-    };
-    /** Checked between two events in drain(): a restart can happen with work still queued. */
-    // True while installing too, so no new turn starts in the half-minute before the restart.
-    const restartDue = () => !!restartTo && (restarting || restartDecision({ ready: restartTo, stopping, working: false, queued: queue.length, live: live.size, readySince, now: Date.now() }));
-    let installFailures = 0;
-    const maybeRestart = async () => {
-        if (stopping || restarting)
-            return;
-        await lookForNewer();
-        if (working)
-            return; // a gap comes at the end of this turn: drain() checks between events
-        if (!restartDecision({ ready: restartTo, stopping, working, queued: queue.length, live: live.size, readySince, now: Date.now() }))
-            return;
-        // Install BEFORE stopping. Coming back up on the same version would only find it "ready"
-        // again ten minutes later — a restart loop — so a failed install keeps this one running.
-        // Nothing to install is fine when another agent on this machine already installed it.
-        restarting = true;
-        if (!isCheckout() && !(await updateSelf((t) => log('tool', t))) && !readyOnDisk(runningVersion)) {
-            restarting = false;
-            restartTo = '';
-            // Soon at first: most failures are a release asked for before npm had it everywhere, and
-            // six hours of the old version for that is what FRIDAY got. Backs off if it keeps failing.
-            const wait = INSTALL_BACKOFF_MIN[Math.min(installFailures++, INSTALL_BACKOFF_MIN.length - 1)];
-            lookAgainAt = Date.now() + wait * 60_000;
-            log('warn', `could not install the newer harness — staying on ${runningVersion}, trying again in ${wait < 60 ? `${wait} min` : `${wait / 60}h`}`);
-            void drain(); // the queue was held for the restart; carry on with it
-            return;
-        }
-        installFailures = 0;
-        log('tool', `restarting into harness ${restartTo}`);
-        shutdown();
-    };
-    const restartTimer = setInterval(() => void maybeRestart(), 10 * 60_000);
-    restartTimer.unref();
     /**
      * An MCP server rejected the session's sign-in: renew it NOW and have the agent retry, instead
      * of the agent concluding the service is broken and flagging a person. Sceneflo rejected HAL
@@ -2466,6 +2207,54 @@ export async function serve(opts) {
         }
         catch { /* keep the order */ }
     }
+    /**
+     * Is a queued event worth a turn? Not when it is for someone else, a move this agent made itself,
+     * a move overtaken by a later one, or a free worker the lead has nothing new for (null: the caller
+     * acknowledges it). Comments on one card that queued up while a turn ran become one event.
+     */
+    async function triage(event) {
+        if (!needsMe(event)) {
+            log('tool', `ignored ${event.event}: ${event.cardCode || 'card'} is not assigned to you (${event.actor || 'someone'})`);
+            return null;
+        }
+        // A move this agent made itself, coming back as an event ("Someone moved it").
+        if (event.event === 'moved' && !event.mentioned && isOwnMove([event.cardCode, event.cardKey], event.laneName)) {
+            log('tool', `ignored moved: ${event.cardCode || event.cardKey} to ${event.laneName} was my own move`);
+            return null;
+        }
+        // A move the card has since moved on from. After a restart, or with several moves in a
+        // minute, these arrive late, and each cost CASE a turn to conclude "out of date, nothing
+        // to do" (HR-0184, 12 Oct). The card's lane now says whether the move still stands.
+        if (event.event === 'moved' && !event.mentioned && event.cardCode && opts.deck) {
+            const now = await opts.deck.card(event.cardCode).then((c) => c?.lane?.name, () => undefined);
+            if (moveIsStale(event, now)) {
+                log('tool', `ignored moved: ${event.cardCode} has since moved on to ${now}`);
+                return null;
+            }
+        }
+        /* Comments on one card that queued up while a turn ran are ONE turn, not one each. TARS
+           finished HR-1019 on 17 Oct to find five comments waiting on it and spent five turns of
+           ~100k saying "nothing new" to each — they had been written while it worked, and the
+           first turn could have read them all. */
+        let merged = [];
+        if ((event.event === 'commented' || event.event === 'mentioned') && event.cardKey) {
+            merged = mergeableComments(queue, event);
+            if (merged.length) {
+                for (const m of merged)
+                    queue.splice(queue.indexOf(m), 1);
+                syncQueue();
+                event = combineComments(event, merged);
+                log('tool', `${event.cardCode || event.cardKey}: ${merged.length + 1} comments waiting on this card — read together in one turn`);
+            }
+        }
+        // A worker saying it is free, with nothing ready to give it: the lead's model would only
+        // read the board and say "nothing". Five idle workers after a restart woke R2-D2 five
+        // times for exactly that. The dispatch timer hands work over once something IS ready.
+        if (profile.dispatch && isFreeWorkerMessage(event) && !(await dispatch.wakeForFree(event))) {
+            return null;
+        }
+        return { event, merged };
+    }
     async function drain() {
         if (working)
             return;
@@ -2482,80 +2271,17 @@ export async function serve(opts) {
                 // Only what needs this agent. A card it once touched keeps sending it every move and
                 // comment made by whoever has it now, and each one cost a full turn — guide, card,
                 // orientation — to conclude "not mine". Acknowledge those without waking the model.
-                if (!needsMe(event)) {
-                    log('tool', `ignored ${event.event}: ${event.cardCode || 'card'} is not assigned to you (${event.actor || 'someone'})`);
-                    pending.delete(event.id);
-                    await stream.ack([event.id]);
-                    continue;
-                }
-                // A move this agent made itself, coming back as an event ("Someone moved it").
-                if (event.event === 'moved' && !event.mentioned && isOwnMove([event.cardCode, event.cardKey], event.laneName)) {
-                    log('tool', `ignored moved: ${event.cardCode || event.cardKey} to ${event.laneName} was my own move`);
+                const original = event;
+                const triaged = await triage(event);
+                if (!triaged) {
                     pending.delete(event.id);
                     await stream.ack([event.id]);
                     continue;
                 }
-                // A move the card has since moved on from. After a restart, or with several moves in a
-                // minute, these arrive late, and each cost CASE a turn to conclude "out of date, nothing
-                // to do" (HR-0184, 12 Oct). The card's lane now says whether the move still stands.
-                if (event.event === 'moved' && !event.mentioned && event.cardCode && opts.deck) {
-                    const now = await opts.deck.card(event.cardCode).then((c) => c?.lane?.name, () => undefined);
-                    if (moveIsStale(event, now)) {
-                        log('tool', `ignored moved: ${event.cardCode} has since moved on to ${now}`);
-                        pending.delete(event.id);
-                        await stream.ack([event.id]);
-                        continue;
-                    }
-                }
-                /* Comments on one card that queued up while a turn ran are ONE turn, not one each. TARS
-                   finished HR-1019 on 17 Oct to find five comments waiting on it and spent five turns of
-                   ~100k saying "nothing new" to each — they had been written while it worked, and the
-                   first turn could have read them all. */
-                const original = event;
-                let merged = [];
-                if ((event.event === 'commented' || event.event === 'mentioned') && event.cardKey) {
-                    merged = mergeableComments(queue, event);
-                    if (merged.length) {
-                        for (const m of merged)
-                            queue.splice(queue.indexOf(m), 1);
-                        syncQueue();
-                        event = combineComments(event, merged);
-                        log('tool', `${event.cardCode || event.cardKey}: ${merged.length + 1} comments waiting on this card — read together in one turn`);
-                    }
-                }
-                // A worker saying it is free, with nothing ready to give it: the lead's model would only
-                // read the board and say "nothing". Five idle workers after a restart woke R2-D2 five
-                // times for exactly that. The dispatch timer hands work over once something IS ready.
-                if (isLead && (event.event === 'message' || event.event === 'mentioned') &&
-                    FREE_WORKER.test(`${event.message ?? ''} ${event.line ?? ''}`)) {
-                    const ready = await readyToHand();
-                    const key = [...ready].sort().join(',');
-                    // Nothing ready, or the very cards the lead already looked at and chose to hold: JARVIS
-                    // woke for every "I am free" to re-read the same five cards and assign none. Woken again
-                    // when the set changes, or after an hour in case whatever held them is gone.
-                    const unchanged = !!key && key === lastFreeLook.key && Date.now() - lastFreeLook.at < 60 * 60_000;
-                    if (!ready.length || unchanged) {
-                        log('tool', `${event.actor || 'a worker'} is free — ${ready.length ? 'the ready cards are the ones already looked at' : 'nothing ready to hand over'}, not waking the model`);
-                        pending.delete(event.id);
-                        await stream.ack([event.id]);
-                        continue;
-                    }
-                    lastFreeLook = { key, at: Date.now() };
-                }
-                // What a person reading the pane wants to know is WHICH card, and a code alone is not
-                // that — you have to go and look it up. "a message" was worse: it did not even say who
-                // from, on a line that sits there for minutes.
+                event = triaged.event;
+                const { merged } = triaged;
                 const cardLabel = event.cardCode || event.cardKey || '';
-                const title = (event.cardName || '').trim();
-                current = event.event === 'ask'
-                    ? 'your question'
-                    : event.event === 'sweep'
-                        ? 'your outstanding work'
-                        : event.event === 'scheduled'
-                            ? event.scheduleName || 'a scheduled task'
-                            : cardLabel
-                                ? `${cardLabel}${title ? ` · ${title.length > 58 ? `${title.slice(0, 57)}…` : title}` : ''}`
-                                : `a message${event.actor ? ` from ${event.actor}` : ''}`;
+                current = workingLabel(event);
                 state.working = current;
                 tag = cardLabel;
                 state.since = Date.now();
@@ -2696,7 +2422,7 @@ export async function serve(opts) {
      * stops reading it, and the whole value is that this message means something.
      */
     async function offerToLead() {
-        if (!leadId || !leadName || isLead || offeredWhileIdle)
+        if (!leadId || !leadName || profile.dispatch || offeredWhileIdle)
             return;
         offeredWhileIdle = true;
         // Short on purpose. A lead reads these between other things, and everything else it needs —
@@ -2923,9 +2649,32 @@ export async function serve(opts) {
             ...(event.cardCode ? { code: event.cardCode } : {}),
         }, reason, kind, undefined, undefined, undefined, undefined, true);
     };
-    async function handle(event) {
+    /**
+     * A turn, stage 1: is this event work for this agent at all? Expired schedules, cards parked on a
+     * person, chatter between others and the harness's own bookkeeping end here, acknowledged without
+     * a turn (null). An assistant's chat is narrowed to its person.
+     */
+    /**
+     * A card as FlareDeck has it, read at most once in a few seconds. A turn's start read the same card
+     * up to three times — the parked check, the queue check, its repositories — each a round trip
+     * before the model could begin. Only the turn's start uses this; decisions made later in a turn
+     * (the finish gate, a release) read the card fresh.
+     */
+    const startReads = new Map();
+    const cardAtStart = (ref) => {
+        const hit = startReads.get(ref);
+        if (hit && Date.now() - hit.at < 5000)
+            return hit.card;
+        const card = (opts.deck?.card(ref) ?? Promise.resolve(null)).catch(() => null);
+        startReads.set(ref, { at: Date.now(), card });
+        for (const [k, v] of startReads)
+            if (Date.now() - v.at > 60_000)
+                startReads.delete(k);
+        return card;
+    };
+    async function admit(event) {
         // An assistant working a card on a board it releases for is a worker for this turn.
-        const isAssistantChat = isAssistant && !assistantCard(event);
+        const isAssistantChat = profile.chat && !assistantCard(event);
         const prefix = codePrefix(event.cardCode);
         if (prefix && !scratchPrefixes.has(prefix)) {
             scratchPrefixes.add(prefix);
@@ -2936,7 +2685,7 @@ export async function serve(opts) {
         // the caller, because skipping it is the finished outcome.
         if (event.event === 'scheduled' && event.validUntil && Date.now() > Date.parse(event.validUntil)) {
             log('warn', `${event.scheduleName || 'scheduled task'}: skipped, it was due ${event.validUntil} and that has passed`);
-            return;
+            return null;
         }
         // A comment on a finished card is news, not work. The server stopped sending these to a
         // card's holder — this is the same rule on this side, for an older server and for any other
@@ -2965,19 +2714,19 @@ export async function serve(opts) {
             /* A lead or manager hears its own team asking it, parked or not: that is what it is there
                for. HR-0761 (18 Oct): TARS escalated to Norm, the manager, and Norm's harness left it
                alone four times because the card was parked on a person. */
-            const byReport = (isLead || isManager) && isTeamAsk(event, agentNames) && afterPark;
+            const byReport = (profile.oversees) && isTeamAsk(event, agentNames) && afterPark;
             const stale = Date.now() - waiting.since > PARK_EXPIRES_MS;
             /* The flag itself cleared — by a person, the manager, or a release — is the answer too.
                HR-0915 (18 Oct): Norm cleared it and released the fix to qa, and HAL left the card alone
                seven times, "waiting on a person", because no person had COMMENTED. */
             let cleared = false;
             if (!byPerson && event.event !== 'decided' && !stale && opts.deck) {
-                const now = await opts.deck.card(event.cardKey || event.cardCode || '').catch(() => null);
+                const now = await cardAtStart(event.cardKey || event.cardCode || '');
                 cleared = !!now && now.needs_human === false;
             }
             if (!unparkReason({ byPerson: byPerson || byBoss || byReport, decided: event.event === 'decided', stale, cleared })) {
                 log('event', `${label}: waiting on a person (${waiting.why}) — left alone`);
-                return;
+                return null;
             }
             for (const k of [event.cardKey, event.cardCode])
                 if (k)
@@ -2989,30 +2738,30 @@ export async function serve(opts) {
         }
         if (event.event === 'commented' && event.cardDone && !event.mentioned) {
             log('event', `${event.cardCode || event.cardKey}: comment on a finished card — nothing to do`);
-            return;
+            return null;
         }
         if (forSomeoneElse(event, agentNames, (opts.agent ?? '').replace(/\s*\(.*$/, ''))) {
             log('event', `${event.cardCode || event.cardKey}: ${event.actor} is talking to somebody else on the card — nothing to do`);
-            return;
+            return null;
         }
         // An assistant hears its person and nothing else, and works outside the card machinery.
         if (isAssistantChat) {
-            const why = assistantIgnores(event, person?.uid ?? null);
+            const why = chat.ignores(event);
             if (why) {
-                log('event', `${event.cardCode || event.event}: ${why} — not for ${person?.name ?? 'anyone'}'s assistant`);
-                return;
+                log('event', `${event.cardCode || event.event}: ${why} — not for ${chat.person()?.name ?? 'anyone'}'s assistant`);
+                return null;
             }
-            event = asAssistantEvent(event, person?.name ?? 'your person');
+            event = chat.asTurn(event);
             // The conversation from before a restart, picked up where it was.
             if (!sessions.has(ASSISTANT_KEY)) {
-                const kept = loadAssistantSession(assistantSessionFile);
+                const kept = chat.kept();
                 if (kept)
                     sessions.set(ASSISTANT_KEY, kept);
             }
         }
         if (isBookkeeping(event, agentNames)) {
             log('event', `${event.cardCode || event.cardKey}: ${event.event === 'commented' ? 'a harness\'s own record on the card' : event.event === 'approval' ? 'an approval for a person to give' : event.event === 'updated' ? 'the card\'s record changed' : 'the card was flagged for a person'} — nothing to do`);
-            return;
+            return null;
         }
         /* One card in progress at a time. Every event on a QUEUED card used to start it: the turn
            moved it to Doing whatever else the worker held, so with Norm queuing cards HAL and TARS
@@ -3020,8 +2769,8 @@ 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 && !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 (!profile.oversees && !isAssistantChat && event.cardKey && event.event !== 'review' && event.event !== 'ask' && !sessions.has(event.cardKey)) {
+            const here = await cardAtStart(event.cardCode || event.cardKey || '');
             if (here && !here.done && String(here.lane?.type ?? '').toLowerCase() !== 'inprogress') {
                 const pv = String(await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'pull-next-card', {
                     preview: true, ...(skipNow().length ? { skip: skipNow() } : {}),
@@ -3031,15 +2780,21 @@ export async function serve(opts) {
                 if (doing && doing !== thisCode) {
                     if (event.event === 'assigned' || event.event === 'moved' || event.event === 'updated') {
                         log('event', `${thisCode || event.cardKey}: queued behind ${doing} — not started now; FlareDeck hands it out when ${doing} is done`);
-                        return;
+                        return null;
                     }
                     queuedBehind = doing;
                 }
             }
         }
+        return { event, isAssistantChat, queuedBehind };
+    }
+    /**
+     * A turn, stage 2: where it works — which repository, which base branch, and a checkout of its own
+     * for a card that will change something. null: the card was flagged for a person or the agent
+     * paused (disk), and there is no turn.
+     */
+    async function placeTurn(event, isAssistantChat) {
         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.
         // Falls back to the repo itself when there is no git or the worktree cannot be made —
         // better to work than to refuse, but the agent is told either way.
@@ -3055,15 +2810,18 @@ export async function serve(opts) {
         // config list to go stale.
         // No repository details on the event (the harness's own pickup): the card names its repository.
         if (event.cardKey && !(event.baseBranches ?? []).length && opts.deck) {
-            const here = await opts.deck.card(event.cardCode || event.cardKey).catch(() => null);
+            const here = await cardAtStart(event.cardCode || event.cardKey || '');
             // Its Repository Components, resolved to repositories by FlareDeck; the legacy "owner/name"
             // component field only if those say nothing.
-            const named = Array.isArray(here?.repositories) ? here.repositories : [];
-            const fromCard = named.length
-                ? named.map((r) => ({ component: '', repository: r.url, branch: '', role: 'feature' }))
-                : baseBranchesFromComponent(here?.component);
+            // With each repository's branch for the card's environment, when FlareDeck sends it.
+            const named = fromCardApi(here?.repositories);
+            const fromCard = named.length ? named : baseBranchesFromComponent(here?.component);
             if (fromCard.length)
                 event = { ...event, baseBranches: fromCard };
+            // …and what it runs alongside, which goes in the card's folder with it (features/card-folder.ts).
+            const beside = fromCardApi(here?.alongside);
+            if (beside.length && !event.alongside?.length)
+                event = { ...event, alongside: beside };
         }
         let repoChoiceNote = '';
         // An assistant's card on a board it releases for: the board says which repository. A card the
@@ -3072,7 +2830,7 @@ export async function serve(opts) {
         // A board with no repository at all (a sales board): the card has no code, so no checkout — it
         // is worked from the assistant's own folder, with its email and calendar tools.
         let assistantNoCode = false;
-        if (isAssistant && !isAssistantChat && !(event.baseBranches ?? []).some((e) => e.repository) && event.boardKey) {
+        if (profile.anyRepo && !isAssistantChat && !(event.baseBranches ?? []).some((e) => e.repository) && event.boardKey) {
             const tid = tenantFromToken(await opts.auth());
             const l = tid ? await fetchLadder(config.mcpUrl, tid, event.boardKey, () => opts.auth()).catch(() => null) : null;
             const urls = (l?.repositories ?? []).map((r) => r.url).filter(Boolean);
@@ -3087,7 +2845,7 @@ export async function serve(opts) {
         // FlareDeck's GitHub connection, into the harness's own folder, and worked from there.
         if (assistantNoCode)
             where = { kind: 'none' };
-        else if (isAssistant && !isAssistantChat && where.kind !== 'repo') {
+        else if (profile.anyRepo && !isAssistantChat && where.kind !== 'repo') {
             const cardRoot = cardReposRoot();
             const gh = flaredeckGithub;
             for (const url of new Set((event.baseBranches ?? []).map((e) => e.repository).filter(Boolean))) {
@@ -3096,7 +2854,11 @@ export async function serve(opts) {
                     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')
+            // Several of them, and the card names no component: that is the question every agent answers
+            // below (the code, then the intake, then a person), not "not on this machine". Dropping it
+            // flagged FRIDAY's HRG-0005 and HRG-0011 six seconds after cloning the very repositories it
+            // said were missing — the website board lists three (29–30 Oct).
+            if (there?.kind === 'repo' || there?.kind === 'ambiguous')
                 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`);
@@ -3161,12 +2923,13 @@ export async function serve(opts) {
         // one, or being mentioned on someone else's — none of those need a checkout, and flagging
         // them for want of one would make the agent unable to answer about a repo it can plainly
         // read. Those turns simply run without a worktree, and the brief says so.
-        const willChange = !!event.cardKey && event.event !== 'review' && event.event !== 'intake' && event.event !== 'ask' && event.forYou !== false && !isLeadDispatch(event, isLead);
+        // An agent that does not change code (profile.code off) never needs a checkout of its own.
+        const willChange = profile.code && !!event.cardKey && event.event !== 'review' && event.event !== 'intake' && event.event !== 'ask' && event.forYou !== false && !isLeadDispatch(event, profile.dispatch);
         if (!chosen && willChange && (where.kind === 'ambiguous' || where.kind === 'unknown')) {
             const reason = askingForComponent(where);
             // Which repository is a technical question about the board's setup, not a business one: COR-0311 (19 Oct) went to its reporter.
             await flagForHuman(event, reason, 'technical');
-            return;
+            return null;
         }
         // A FIX with no branch of its own is the one case worth stopping for.
         //
@@ -3182,7 +2945,7 @@ export async function serve(opts) {
                 `feature branch would base the fix on unreleased work. Set the branch for ${event.environment || 'this environment'} ` +
                 `on the board's repository configuration and this will be picked up.`;
             await flagForHuman(event, reason, 'technical');
-            return;
+            return null;
         }
         const repo = chosen?.path ?? config.repo;
         const startFrom = fromCard?.branch ?? loadBaseBranch(repo) ?? config.baseBranch ?? undefined;
@@ -3212,16 +2975,30 @@ export async function serve(opts) {
                 const wall = await walls();
                 if (wall) {
                     await enterPause(wall);
-                    return;
+                    return null;
                 }
             }
         }
         // An intake review reads the card and the code; it builds nothing, so it gets no checkout. HR-1004's
         // review made a full worktree (and from dev, which the board no longer uses) just to read a card.
-        const tree = event.event === 'intake' || isLeadDispatch(event, isLead) || assistantNoCode ? null
+        // A card with more than one repository — what it changes and what it runs alongside — gets a
+        // folder holding a worktree of each (features/card-folder.ts); one repository, a lone worktree.
+        // Only a profile with folders (solo): in a team, the others run beside the card and a change
+        // that belongs in one goes back to the lead, who gives it to whoever owns that repository.
+        const companions = profile.folders && chosen && event.cardKey && willChange ? companionRepos(event, chosen.origin) : [];
+        const lone = () => ensureWorktree(repo, key, (t) => log('tool', t), startFrom, config.worktreeLocalFiles);
+        const made = !profile.code || event.event === 'intake' || isLeadDispatch(event, profile.dispatch) || assistantNoCode ? null
             : event.cardKey && (chosen || where.kind === 'none')
-                ? await ensureWorktree(repo, key, (t) => log('tool', t), startFrom, config.worktreeLocalFiles)
+                ? (companions.length
+                    ? (await openCardFolder(repo, key, startFrom, companions, { source: sourceFor, onStep: (t) => log('tool', t), ...(config.worktreeLocalFiles ? { local: config.worktreeLocalFiles } : {}) })) ?? (await lone())
+                    : await lone())
                 : await worktreeTheMessageIsAbout(event, repo, (t) => log('tool', t), (code) => ensureWorktree(repo, code, (t) => log('tool', t), startFrom, config.worktreeLocalFiles));
+        // A folder made by an earlier turn, or found again after a restart, comes back whole.
+        const tree = made ? await withCompanions(made) : null;
+        if (tree?.companions?.length)
+            writeFolderScript(tree, (r) => storedStartScript(config.startScripts, r), chosen?.origin ?? '', where.kind === 'repo' ? where.script : undefined);
+        if (tree?.companions?.length)
+            log('tool', `card folder ${tree.folder}: ${[tree.path, ...tree.companions.map((c) => c.path)].map((p) => p.split('/').pop()).join(', ')}`);
         /**
          * Questions about a CARD get their own session, not the shared one.
          *
@@ -3240,26 +3017,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 = 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,
-            // once, as one message marked as the past.
-            const posted = `${assistantSessionFile}.history`;
-            if (person && !existsSync(posted)) {
-                const ex = recentExchanges(join(claudeProjectDir(config.repo), `${pickedUp}.jsonl`));
-                if (ex.length) {
-                    const name = (opts.agent ?? 'your assistant').replace(/\s*\(.*$/, '');
-                    await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'send-message', { to: person.uid, message: historyMessage(ex, name) })
-                        .then(() => { try {
-                        mkdirSync(dirname(posted), { recursive: true });
-                        writeFileSync(posted, pickedUp);
-                    }
-                    catch { /* posted; a repeat is harmless */ } log('tool', `posted the last ${ex.length} exchanges to ${person.name}'s chat`); })
-                        .catch((e) => log('warn', `could not post the earlier conversation to the chat: ${e instanceof Error ? e.message : String(e)}`));
-                }
-            }
-        }
+        const pickedUp = isAssistantChat && key === ASSISTANT_KEY && !sessions.get(key) ? await chat.pickUp() : null;
         // 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 = isAssistantChat ? config.repo : tree?.path ?? repo;
@@ -3283,17 +3041,17 @@ export async function serve(opts) {
         // A lead's folder often holds no code at all (R2-D2: ~/Source/Kepler/kepler-agent). Handed a
         // card to build, it flagged a person to "fix the repository" (KD-1354) — when its job is to
         // pass the card to a worker who has the code. So it is told that, and the turn runs.
-        const leadWithoutCode = !tree && willChange && !!event.cardKey && isLead;
+        const leadWithoutCode = !tree && willChange && !!event.cardKey && profile.dispatch;
         // An agent whose folder holds no repository at all works in place: there is no checkout of
         // anyone's to protect, which is the whole reason for the flag below. C3PO (PayInc's assistant,
         // a folder of notes and documents) was asked to reword a card and told five people it had
         // "nowhere safe to do the work" (COR-0307).
         const noRepositoryHere = !chosen && where.kind === 'none' && !existsSync(join(repo, '.git'));
-        if (!tree && willChange && event.cardKey && !isLead && !noRepositoryHere) {
+        if (!tree && willChange && event.cardKey && !profile.dispatch && !noRepositoryHere) {
             await flagForHuman(event, `I could not make a checkout of my own for this card in ${chosen?.name ?? repo}, so there is nowhere ` +
                 `safe to do the work. Everything I changed would land in a checkout somebody else may be using. ` +
                 `Something is wrong with the repository or the branch this card asks for — a person needs to look.`, 'technical');
-            return;
+            return null;
         }
         if (tree) {
             state.branch = tree.branch;
@@ -3303,135 +3061,126 @@ export async function serve(opts) {
         // from anywhere else: which project this card is actually being changed in.
         if (chosen)
             state.repo = chosen.path;
-        // FlareDeck must be there before the model is. Without it the turn cannot read the card,
-        // comment, or ask for help — and it would still run, answer fluently that it could not do
-        // the work, and be acknowledged. The card would be gone. So: no FlareDeck, no turn.
-        // The plan for this run is asked for now, alongside the check, instead of after everything
-        // else: one more round trip the person was waiting on. Awaited where it is used.
-        const subsEarly = subscriptionsForAgent(config.mcpUrl, () => opts.auth(), (t) => log('tool', t));
-        const planEarly = subsEarly.then((sc) => (sc ? sc.choose(failedPlans.get(event.id) ?? []) : null)).catch(() => null);
-        const check = await preflightFlaredeck(config.mcpUrl, await opts.auth());
-        if (!check.ok) {
-            log('warn', check.reason);
-            throw new CouldNotWork(`${check.reason} — event left queued`);
+        return { event, key, where, chosen, repo, startFrom, tree, cwd, leadWithoutCode, repoChoiceNote, pickedUp };
+    }
+    /**
+     * A turn, stage: what it runs on. The required MCP servers must be connected; a Claude
+     * subscription is chosen by FlareDeck (or this machine's own login when FlareDeck cannot say);
+     * with every plan spent the event waits for the soonest reset, and past Gemini's spend limit the
+     * turn runs on Claude. null: no turn now — paused, waiting, or the card flagged.
+     */
+    async function choosePlan(event, key, subsEarly, planEarly) {
+        /**
+         * Which Claude subscription pays for this run.
+         *
+         * Three subscriptions and twenty-odd agents, with daily and weekly caps that trip at
+         * different times, used to mean going round the machines logging in again. FlareDeck holds
+         * the tokens and the ledger now and picks one per run.
+         *
+         * Not reaching FlareDeck is NOT the same as having nothing left: `machine` means carry on
+         * with whatever this box is logged in as, exactly as before any of this existed. Only
+         * `none` — every subscription genuinely spent or paused — stops the run, and it says when
+         * one frees up rather than failing blankly.
+         */
+        /* The MCP list, fresh for this session — and a required server that is not connected stops
+           the work here, before a plan is spent on a card that cannot be done properly. */
+        const missingMcp = await refreshMcp();
+        if (missingMcp?.length) {
+            await enterPause(mcpWallFor(missingMcp));
+            return null;
         }
-        log('tool', `FlareDeck reachable · ${check.discovered.tools.length} tools`);
-        // Served from in here for this turn: a fresh token per call, so a card that outlives the
-        // token's hour keeps its tools, and nothing on this machine can shadow the server by name.
-        // The gate on calling a card finished: it must have commits of its own, published. Checked
-        // here rather than trusted, because a turn that produced nothing still reports confidently.
-        const finishGate = async (toLane) => {
-            // A released card moving on to testing or review is the next step of the board's flow.
-            if (opts.deck) {
-                const here = await opts.deck.card(tag || event.cardCode || event.cardKey || '').catch(() => null);
-                const released = !!here && ((Array.isArray(here.releases) && here.releases.length > 0) || !!here.deployedAt);
-                if (here && toLane && isAfterReleaseMove(toLane, here.lane?.type, here.lane?.name, released)) {
-                    log('tool', `moving ${here.code || tag} on to ${toLane} — it was released already, so this is the next step, not a hand-back`);
-                    return null;
-                }
-                if (here && isReleasedClose(toLane ?? '', released)) {
-                    log('tool', `closing ${here.code || tag} — its work was released already`);
-                    return null;
-                }
-            }
-            const why = await tooEarlyToFinish(tree);
-            /* A LEAD moving a card on with nothing of its own on the branch is dispatch, not a claim of
-               finished work: the code lives on the worker's branch, often already merged. The gate
-               refused JARVIS moving HR-0634 (PR #75 merged, on qa) to "On test site", and the lead then
-               flagged a person to do the move — an intervention nobody needed. Kept for a lead that HAS
-               committed work of its own: that still has to be published before the card moves. */
-            const cardCode = event.cardCode || tag;
-            if (why && tree && cardCode && (await produced(tree)).commits === 0 && await cardWorkOnBase(tree.path, startFrom, cardCode)) {
-                log('tool', `moving ${cardCode} on — its work is already merged into ${startFrom ?? 'the base branch'}, on an earlier branch`);
-                return null;
-            }
-            if (why && tree && !finishRefusalStands(why, isLead || isManager, (await produced(tree)).commits)) {
-                log('tool', `moving ${event.cardCode || event.cardKey || 'the card'} on as lead — the work is on a worker's branch, not mine`);
-                return null;
-            }
-            if (why) {
-                log('warn', `refused a "done" on an empty branch: ${tree?.branch ?? '(no branch)'}`);
-                return why;
-            }
-            // If this agent reports to someone, it does not decide that its own work is finished. The
-            // lead said "I'll check its saved work myself before it goes anywhere" and then was never
-            // told: the card moved itself to Awaiting Deployment. A report hands back; the lead moves
-            // it, or comments and sends it back, which is what a lead is for.
-            if (!leadId)
-                return null;
-            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);
+        const subs = await subsEarly.catch(() => null);
+        const claudePlan = await planEarly;
+        if (claudePlan?.use === 'token') {
+            log('tool', `claude: ${claudePlan.label}`);
+            // On the identity line too, not only in the scrollback: the scrollback moves on, and
+            // "which account is this agent spending" is a thing you glance at, not search for.
+            state.claudeAccount = claudePlan.label;
+            // Measured again once this event is done — see measurePlan.
+            turnPlan = { id: claudePlan.id, label: claudePlan.label, token: claudePlan.token };
+            planOfSession.set(key, claudePlan.token);
+        }
+        // Gemini answers on agy, so spent Claude plans stop it only when Claude is needed — at the
+        // Gemini limit, below.
+        if (claudePlan?.use === 'none' && engine.name !== 'antigravity') {
+            const when = claudePlan.availableAt ? new Date(claudePlan.availableAt).toLocaleString() : 'later';
+            const tried = failedPlans.get(event.id)?.length ?? 0;
+            failedPlans.delete(event.id);
+            /**
+             * Spent, not paused: the harness knows to the minute when a plan comes back — FlareDeck's
+             * answer carries the soonest reset — so it waits for it and carries on by itself. Nobody is
+             * asked to do anything about a clock. Only a fleet with NO reset coming (every plan paused,
+             * which only a person undoes) is flagged.
+             */
+            if (claudePlan.availableAt && claudePlan.availableAt > Date.now()) {
+                const at = claudePlan.availableAt;
+                if (!waitingForPlan.has(event.id)) {
+                    // A little after the reset, so the first request is not refused for being a second early.
+                    const timer = setTimeout(() => {
+                        waitingForPlan.delete(event.id);
+                        log('event', `a Claude subscription is back — resuming ${event.cardCode || event.line}`);
+                        if (enqueue(event, true))
+                            void drain();
+                    }, at - Date.now() + 60_000);
+                    timer.unref?.();
+                    waitingForPlan.set(event.id, timer);
                 }
+                log('warn', `every Claude subscription is spent${tried ? ` (${tried} failed on this turn)` : ''} — waiting, resuming at ${new Date(at).toLocaleTimeString()}`);
+                return null;
             }
-            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'}` : ''}.`
-                    : 'No branch: nothing of mine is in a checkout for this card.';
-                try {
-                    const token = await opts.auth();
-                    await callFlaredeckTool(config.mcpUrl, token, 'assign-card', { card_id: code, assignee: leadId });
-                    await callFlaredeckTool(config.mcpUrl, token, 'send-message', {
-                        to: leadId,
-                        message: `**${code} is ready for your review.**\n\n${where}\n\n` +
-                            `I have not moved it — it is assigned to you and still in its lane. ` +
-                            `Check the work and move it on, or comment on the card and I will fix it.`,
-                    });
-                    log('tool', `handed ${code} to ${leadName} for review`);
+            log('warn', `every Claude subscription is spent or paused${tried ? ` (${tried} failed on this turn)` : ''} — the soonest frees up ${when}`);
+            await flagCard({ card: event.cardKey ?? '', ...(event.boardKey ? { board: event.boardKey } : {}), ...(event.cardCode ? { code: event.cardCode } : {}) }, `I cannot start this card: every Claude subscription in FlareDeck is spent, paused` +
+                `${tried ? ', or just failed on this card' : ''}. ` +
+                `The soonest one frees up ${when}.\n\nNothing is wrong with the card. Add or unpause a ` +
+                `subscription on the Integrations page, or wait for the window to reset.`, 'technical');
+            return null;
+        }
+        /*
+         * Gemini bills per token, so a workspace sets a dollar limit on it (Integrations → Secrets).
+         * Reached, the turn runs on Claude instead — the same agent, its subscription chosen above —
+         * and Gemini answers again once the limit resets (Cobus, 16 Oct). No Claude to fall back on:
+         * the card waits for the reset, as it would for a spent plan.
+         */
+        let turnEngine = engine;
+        if (engine.name === 'antigravity') {
+            const spend = await geminiSpend?.status().catch(() => null);
+            if (spend?.over) {
+                if (claudePlan?.use === 'token') {
+                    turnEngine = claudeFallback ??= new (await import('./engine-claude.js')).ClaudeEngine();
+                    if (!geminiOver)
+                        log('warn', `${spend.over.message} — Claude answers until ${new Date(spend.over.until).toLocaleString()}`);
+                    geminiOver = true;
                 }
-                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.`;
+                else {
+                    const at = spend.over.until;
+                    if (!waitingForPlan.has(event.id)) {
+                        const timer = setTimeout(() => {
+                            waitingForPlan.delete(event.id);
+                            log('event', `the Gemini limit has reset — resuming ${event.cardCode || event.line}`);
+                            if (enqueue(event, true))
+                                void drain();
+                        }, at - Date.now() + 60_000);
+                        timer.unref?.();
+                        waitingForPlan.set(event.id, timer);
+                    }
+                    log('warn', `${spend.over.message}, and there is no Claude subscription to fall back on — waiting until ${new Date(at).toLocaleString()}`);
+                    return null;
                 }
             }
-            return (`${code} is now ${leadName}'s to verify, not yours to close. It is assigned to them and ` +
-                `they have been told, with your branch. Leave the lane alone — they move it on, or comment ` +
-                `and send it back to you. Your part is done; say nothing further about it being finished.`);
-        };
-        // A turn woken by a message says "a message from JARVIS" for as long as it runs, even while
-        // it is plainly working a card. The card tools name the card; this takes it from there, and
-        // only when the turn had none of its own.
-        // Ground truth for the footer on anything this agent says. Null without a worktree: there is
-        // no branch to report on, and a footer saying "nothing committed" would be misleading rather
-        // than informative.
-        const savedSoFar = async () => {
-            if (!tree)
-                return null;
-            const { commits, pushed, branch, known } = await produced(tree);
-            return { branch, commits, pushed, known };
-        };
-        const noteCard = (code) => {
-            if (!code || tag)
-                return;
-            tag = code;
-            state.working = code;
-        };
-        const flaredeck = flaredeckProxy(config.mcpServerName, config.mcpUrl, opts.auth, check.discovered, (w) => log('warn', w), finishGate, noteCard, keepTool, savedSoFar, [...myBoards]);
+            else if (geminiOver && spend) {
+                log('event', 'the Gemini limit has reset — Gemini answers again');
+                geminiOver = false;
+            }
+        }
+        return { subs, claudePlan, turnEngine };
+    }
+    /**
+     * A turn, stage: the card read before the model is. A session already open on it is resumed; a
+     * new one gets intake (the card digested, sized, and a model chosen for it). Evidence still
+     * coming makes the event wait; a card that cannot start is flagged (null). Work starting moves
+     * the card to in-progress.
+     */
+    async function prepareCard(event, key, repo, queuedBehind) {
         const held = live.get(key);
         if (held?.timer)
             clearTimeout(held.timer);
@@ -3481,7 +3230,7 @@ export async function serve(opts) {
             waitingSince.delete(event.cardKey);
         if (prepared?.blocked) {
             await flagForHuman(event, `Cannot start: ${prepared.blocked}`);
-            return;
+            return null;
         }
         // Work starting is work in progress: a card still waiting in backlog, to-do or bug moves to the
         // board's first In Progress lane. Only on a fresh start, and only out of the waiting lanes —
@@ -3489,30 +3238,15 @@ export async function serve(opts) {
         if (!resume && event.cardKey && event.event !== 'review' && event.event !== 'ask' && !queuedBehind) {
             await startOnBoard(event.cardCode || event.cardKey);
         }
-        /**
-         * Which card this turn is about — including when nobody dispatched it.
-         *
-         * This was set only from the event's own cardKey, so a question typed in the pane about a
-         * card had none: the agent had the card, its checkout and its environment, hit a sign-in it
-         * could not pass, and was told "there is no card being worked, so there is nobody to ask
-         * about it". It fell back to leaving a comment, which nobody is notified about. The one
-         * moment the escalation exists for, and it was unavailable.
-         *
-         * `tag` is the code the turn resolved to — from the event, or from the card a pane question
-         * named. FlareDeck takes a human code wherever it takes a card id, so the code alone is
-         * enough to flag, comment and clear.
-         */
-        onCard = event.cardKey
-            ? {
-                card: event.cardKey,
-                cwd,
-                ...(event.boardKey ? { board: event.boardKey } : {}),
-                ...(event.cardCode ? { code: event.cardCode } : {}),
-            }
-            : tag
-                ? { card: tag, cwd, code: tag, ...(event.boardKey ? { board: event.boardKey } : {}) }
-                : null;
-        job = tree
+        return { resume, prepared };
+    }
+    /**
+     * What committing and publishing this card's checkout needs: its branch and base, where the
+     * card's Parts are recorded, what to do when GitHub refuses a push, and the token to push with
+     * (FlareDeck's GitHub connection first, this machine's login otherwise). null without a checkout.
+     */
+    async function publishJob(event, key, tree, cwd, startFrom) {
+        return tree
             ? {
                 cwd,
                 branch: tree.branch,
@@ -3520,6 +3254,8 @@ export async function serve(opts) {
                 // back to the repo's default branch when it has not.
                 base: startFrom ?? (await baseBranch(cwd)),
                 card: event.cardCode || key,
+                // The other repositories in the card's folder, published by name.
+                ...(tree.companions?.length ? { others: tree.companions.map((c) => ({ name: c.name, cwd: c.path, branch: c.branch, base: c.base })) } : {}),
                 // The card's Parts, from what the branch changes (board settings → part paths).
                 onPublished: async (files, where) => {
                     if (!event.cardKey)
@@ -3563,6 +3299,14 @@ export async function serve(opts) {
                 },
             }
             : null;
+    }
+    /**
+     * A turn, stage: the project running, when the card needs it. Declared preflight checks for a
+     * card's checkout; the environment reused if it is still up here, started if intake says the card
+     * needs it (never for a manager); and the tools to start it on request, ask for a sign-in, and
+     * look at it in a browser. `envNow()` is what is running now — the agent may start it mid-turn.
+     */
+    async function bringUpEnvironment(event, tree, cwd, where, prepared) {
         // Declared checks are OPTIONAL: no .flaredeck/agent.yaml means none, and that is the normal
         // case. Judging what a task needs is the agent's job — it can read the card and the repo, and
         // most cards need nothing. This is only for the few things a project wants hard-gated
@@ -3584,24 +3328,42 @@ export async function serve(opts) {
         // answers from the card, the board and machine-exec. Norm waited five minutes on a start
         // script that hung before answering a yes/no question from CASE — twice in one morning —
         // and then reported its own broken environment to the lead. start_environment is still there.
-        const needsRunning = wantsEnvironment(isManager, prepared?.jev?.needs_running);
+        const needsRunning = wantsEnvironment(!profile.environments, prepared?.jev?.needs_running);
         /* Already up in this checkout from an earlier turn — reuse it. After a handover the next
            session ran the start script again on a live environment, the script refused ("harness
            already up, run down first"), and the card lost its app. Checked, not trusted: one that
            stopped answering is started fresh. */
         const cachedEnv = envUp.get(cwd);
-        const reuse = forACard && needsRunning && cachedEnv && await environmentStillUp(cachedEnv);
+        const reuse = forACard && needsRunning && cachedEnv && await environmentStillUp(cachedEnv, 2000, cwd);
         if (reuse)
             log('tool', `environment already up here — reusing it${Object.keys(cachedEnv.endpoints).length ? ` (${Object.keys(cachedEnv.endpoints).join(', ')})` : ''}`);
+        // What the card needs running beside its own repository — a site's API and CMS — deployed or
+        // started once and shared (features/services.ts); their addresses go to its start script.
+        const startsHere = !reuse && forACard && needsRunning;
+        // A card folder runs every repository in it from its worktree — the site talks to the API and
+        // CMS code beside it, so a change in either is what gets tested. Otherwise, alongside services.
+        const inFolder = tree?.companions ?? [];
+        const alongside = startsHere && inFolder.length
+            ? await stopOtherEnvironments(cwd).then(() => startFolder(inFolder, event.environment ?? ''))
+            : startsHere && event.alongside?.length ? await services.ensure(event.alongside, event.environment ?? '')
+                : reuse && companionNotes.get(cwd) ? companionNotes.get(cwd)
+                    : { env: {}, notes: [] };
+        if (startsHere && inFolder.length)
+            companionNotes.set(cwd, alongside);
+        for (const n of alongside.notes)
+            log('tool', `alongside: ${n}`);
+        // 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 — else the one kept in FlareDeck.
+        const stored = where.kind === 'repo' ? storedStartScript(config.startScripts, where.checkout.origin) : undefined;
         let env = reuse
             ? cachedEnv
-            : 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 stopOtherEnvironments(cwd).then(() => startEnvironment(cwd, (t) => log('tool', t), where.kind === 'repo' ? where.script : undefined))
+            : startsHere
+                ? await stopOtherEnvironments(cwd).then(() => startEnvironment(cwd, (t) => log('tool', t), where.kind === 'repo' ? where.script : undefined, { ...(stored ? { script: stored } : {}), env: alongside.env }))
                 : { ran: false, ok: true, endpoints: {}, detail: '' };
-        if (env.ran && env.ok)
+        if (env.ran && env.ok) {
             envUp.set(cwd, env);
+            envHow.set(cwd, { ...(where.kind === 'repo' && where.script ? { declared: where.script } : {}), ...(stored ? { stored } : {}) });
+        }
         // The guard is built once at startup; what this agent can reach changes per card. Handing it
         // the live picture is the difference between judging "$DATABASE_URL" as a scratch database
         // and judging it as a live one.
@@ -3624,7 +3386,106 @@ export async function serve(opts) {
         const envTools = environmentTools({
             cwd: () => cwd,
             script: () => (where.kind === 'repo' ? where.script : undefined),
+            stored: () => (where.kind === 'repo' ? storedStartScript(config.startScripts, where.checkout.origin) : undefined),
+            alongsideEnv: () => alongside.env,
+            // An agent's start script, proved here, kept in FlareDeck for this repository (step 3 of
+            // docs/spec-workspace-repositories.md): every agent after it gets a running project.
+            ...(where.kind === 'repo' ? {
+                saveStartScript: async (script) => {
+                    const r = await saveStartScriptFor(where.checkout.origin, script);
+                    if (r.ok) {
+                        log('tool', `start script saved in FlareDeck for ${where.checkout.name}`);
+                        keepStartScript(where.checkout.origin, script);
+                    }
+                    return r;
+                },
+            } : {}),
             running: () => (env.ran ? env : null),
+            // The card's folder: start some or all of it, start what is missing, keep a start script for
+            // any repository in it (features/card-folder.ts). When an address the card's own repository
+            // was given moves, it restarts too, so it is never left talking to a dead port.
+            ...(inFolder.length ? {
+                folder: (() => {
+                    const mainName = cwd.split('/').pop() ?? '';
+                    const restartMain = async () => {
+                        await stopEnv(cwd).catch(() => false);
+                        envUp.delete(cwd);
+                        const own = where.kind === 'repo' ? storedStartScript(config.startScripts, where.checkout.origin) : undefined;
+                        const again = await startEnvironment(cwd, (t) => log('tool', t), where.kind === 'repo' ? where.script : undefined, { ...(own ? { script: own } : {}), env: alongside.env });
+                        if (again.ran && again.ok) {
+                            env = again;
+                            reachable = { cwd, endpoints: env.endpoints };
+                            envUp.set(cwd, again);
+                            envHow.set(cwd, { ...(where.kind === 'repo' && where.script ? { declared: where.script } : {}), ...(own ? { stored: own } : {}) });
+                            return `${mainName} is running: ${Object.entries(again.endpoints).map(([k, v]) => `${k} ${v}`).join(', ') || 'no addresses printed'}.`;
+                        }
+                        return `${mainName} did not come up: ${again.detail.split('\n').filter(Boolean).pop() ?? 'no start script'}.`;
+                    };
+                    /** Bring these companions up again and hand their addresses on; true when one moved. */
+                    const bring = async (cs) => {
+                        for (const c of cs) {
+                            await stopEnv(c.path).catch(() => false);
+                            envUp.delete(c.path);
+                        }
+                        const r = await startFolder(cs, event.environment ?? '');
+                        const moved = Object.entries(r.env).some(([k, v]) => alongside.env[k] !== v);
+                        Object.assign(alongside.env, r.env);
+                        companionNotes.set(cwd, alongside);
+                        return { notes: r.notes, moved };
+                    };
+                    const find = (n) => inFolder.find((x) => x.name.toLowerCase() === n.toLowerCase());
+                    return {
+                        names: () => [mainName, ...inFolder.map((x) => x.name)],
+                        startMissing: async () => {
+                            const missing = inFolder.filter((c) => !envUp.has(c.path));
+                            if (!missing.length)
+                                return companionNotes.get(cwd)?.notes ?? [];
+                            await stopOtherEnvironments(cwd);
+                            return (await bring(missing)).notes;
+                        },
+                        start: async (names) => {
+                            const unknown = names.filter((n) => !find(n) && n.toLowerCase() !== mainName.toLowerCase());
+                            if (unknown.length)
+                                return { ok: false, text: `Not in your card's folder: ${unknown.join(', ')}. It holds: ${[mainName, ...inFolder.map((x) => x.name)].join(', ')}.` };
+                            await stopOtherEnvironments(cwd);
+                            const cs = names.map(find).filter((c) => !!c);
+                            const { notes, moved } = cs.length ? await bring(cs) : { notes: [], moved: false };
+                            const wantMain = names.some((n) => n.toLowerCase() === mainName.toLowerCase());
+                            let text = notes.join('\n');
+                            if (wantMain || (moved && env.ran))
+                                text += `${text ? '\n' : ''}${moved && !wantMain ? `An address changed, so ${mainName} was restarted to use it. ` : ''}${await restartMain()}`;
+                            return { ok: !/not running|did not start|did not come up|deployed one is used/.test(text), text: text || 'Nothing to start.' };
+                        },
+                        saveScript: async (name, path, body) => {
+                            const c = find(name);
+                            if (!c)
+                                return { ok: false, text: `There is no "${name}" in your card's folder. It holds: ${[mainName, ...inFolder.map((x) => x.name)].join(', ')}.` };
+                            await stopEnv(c.path).catch(() => false);
+                            envUp.delete(c.path);
+                            const started = await startEnvironment(c.path, (t) => log('tool', `${c.name}: ${t}`), undefined, { script: path });
+                            if (!started.ok || !Object.keys(started.endpoints).length) {
+                                const detail = (started.detail || '').trim().split('\n').slice(-12).join('\n');
+                                return { ok: false, text: `${c.name} did not come up${started.ok ? ' with an address (no name=url line)' : ''}, so it was not saved.\n\n${detail || '(it printed nothing)'}\n\nFix it and try again.` };
+                            }
+                            const saved = await saveStartScriptFor(c.repository, body);
+                            const kept = keepStartScript(c.repository, body) ?? path;
+                            envUp.set(c.path, started);
+                            envHow.set(c.path, { ...(c.script ? { declared: c.script } : {}), stored: kept });
+                            const url = Object.values(started.endpoints)[0];
+                            const before = { ...alongside.env };
+                            alongside.env[envName(c.type || 'service')] = url;
+                            alongside.env[envName(serviceDir(c.repository))] = url;
+                            companionNotes.set(cwd, { env: alongside.env, notes: [...(companionNotes.get(cwd)?.notes ?? []).filter((n) => !n.startsWith(`${c.name}:`)), `${c.name}${c.type ? ` (${c.type})` : ''}: running from your folder, ${url}`] });
+                            writeFolderScript(tree, (r) => storedStartScript(config.startScripts, r), where.kind === 'repo' ? where.checkout.origin : '', where.kind === 'repo' ? where.script : undefined);
+                            const moved = Object.entries(alongside.env).some(([k, v]) => before[k] !== v);
+                            const main = moved && env.ran ? `\n\n${mainName} was restarted to use it. ${await restartMain()}` : '';
+                            return saved.ok
+                                ? { ok: true, text: `Saved in FlareDeck for ${c.name}, and running from your folder: ${url}.${main}\n\nTell your lead in one line that ${c.name} now has a start script.` }
+                                : { ok: false, text: `It works — ${c.name} is running at ${url} — but FlareDeck did not keep it: ${saved.message ?? 'no reason given'}. Say so on the card.${main}` };
+                        },
+                    };
+                })(),
+            } : {}),
             // The same deployed addresses the browser gets, so a sign-in can be asked for the dev or
             // UAT site and not only for something this card started.
             sites: () => declaredSites,
@@ -3642,145 +3503,42 @@ export async function serve(opts) {
             },
             onNote: (t) => log('tool', t),
             beforeStart: () => stopOtherEnvironments(cwd),
-            /**
-             * Turning "ask somebody" into something that actually asks.
-             *
-             * Three pieces already worked and were never joined up: open_page DETECTS a sign-in wall
-             * and says which kind it is, signInSession captures a session a person completes by hand,
-             * and loadSession replays it for every later card. The gap was the middle. All wallBrief
-             * could do was tell the agent in prose to ask, with no tool to call — so the agent wrote a
-             * comment, flagged the card and stopped. That was the only thing available to it, and it
-             * read like a model that would not try.
-             *
-             * So: start the viewer, flag the card with the address (a flag is what reaches a phone),
-             * and when the session lands, store it, clear the flag and put the card back at the front
-             * of the queue. The agent's next turn opens the app already signed in.
-             *
-             * The viewer is LOOPBACK, deliberately: it drives a browser part-way through somebody's
-             * sign-in, which is not a thing to publish on a reachable port. So the person has to be at
-             * this machine. That is the case this is for — an agent testing localhost on a developer's
-             * own box — and for a cloud agent it is a stated limit rather than a silent failure.
-             */
+            // Asking a person to sign in, through FlareDeck's relay: see features/sign-in-request.ts.
             ...(onCard
                 ? {
-                    requestSignIn: async ({ part, url, why }) => {
-                        const card = onCard;
-                        if (!card)
-                            return { asked: false, why: 'the card went away while this was being asked' };
-                        if (!(await ensureBrowser((t) => log('tool', `browser: ${t}`)))) {
-                            return { asked: false, why: 'this machine has no browser and could not fetch one' };
-                        }
-                        const { chromium } = await import('playwright-core');
-                        const { signInSession } = await import('./signin.js');
-                        const { rememberSignInNow, HEADLESS_FULL } = await import('./browser.js');
-                        const { randomBytes } = await import('node:crypto');
-                        /* Through FlareDeck, not through a port on this machine. The person may be on a
-                           phone and the agent may be on a cloud box, which is the case this exists for;
-                           loopback only ever served the one where they are in the same room. */
-                        const id = `sgn_${randomBytes(9).toString('base64url')}`;
-                        /* agent-service, not the MCP. The relay was first built onto flaredeck-mcp, which
-                           cannot host it: the MCP deploys as a Firebase Function, and a Function hands you
-                           (req, res) with no http.Server underneath, so a WebSocket upgrade can never
-                           complete there. agent-service is a real Cloud Run service and already the one
-                           this harness holds an event stream open to. */
-                        const serviceUrl = process.env['FLAREDECK_RELAY_URL'] ?? config.agentServiceUrl;
-                        if (!serviceUrl) {
-                            // Configured by default, so this means somebody blanked it. Say which setting.
-                            return { asked: false, why: 'this harness has no agentServiceUrl, so a sign-in cannot be relayed' };
-                        }
-                        const relayBase = serviceUrl.replace(/^http/, 'ws').replace(/\/+$/, '');
-                        const appBase = (process.env['FLAREDECK_APP_URL'] ?? 'https://app.flaredeck.app').replace(/\/+$/, '');
-                        const viewerUrl = (t) => `${appBase}/signin/${id}?t=${encodeURIComponent(t)}`;
-                        /* Resolve as far as the ADDRESS and no further. Waiting for the sign-in itself would
-                           hold the agent's tool call open for as long as a person takes to get to their
-                           machine, and not waiting is the whole point: the card parks, the turn ends. */
-                        let settle;
-                        const ready = new Promise((r) => { settle = r; });
-                        const ref = {
-                            card: card.card,
-                            ...(card.board ? { board: card.board } : {}),
-                            ...(card.code ? { code: card.code } : {}),
-                        };
-                        // Held up while the person has not signed in yet — see signInPending.
-                        const signCwd = turnCwd;
-                        if (signCwd)
-                            signInPending.set(signCwd, Date.now());
-                        /* The page's console, forwarded — but a page retrying something gone repeats one
-                           line hundreds of times. The first is logged; repeats are counted and summarised. */
-                        let lastNote = '';
-                        let repeats = 0;
-                        const pageNote = (t) => {
-                            if (t === lastNote) {
-                                repeats++;
-                                if (repeats === 3 || repeats % 50 === 0)
-                                    log('tool', `sign-in: (the same line ${repeats + 1}× so far) ${t.slice(0, 120)}`);
-                                return;
-                            }
-                            lastNote = t;
-                            repeats = 0;
-                            log('tool', `sign-in: ${t}`);
-                        };
-                        void signInSession({
-                            url,
-                            launch: () => chromium.launch(HEADLESS_FULL),
-                            relay: { url: relayBase, token: await opts.auth(), id, viewerUrl },
-                            onReady: (viewer) => {
-                                log('tool', `sign-in wanted for "${part}" — ${viewer}`);
-                                void flagCard(ref, `${url} needs someone to sign in before this card can go on. ${why}\n\n` +
-                                    `Open the sign-in below and do it there. It is this agent's real browser, ` +
-                                    `shown live — click and type in the picture, then press Save & finish. The ` +
-                                    `session is kept for the whole project, so this is once, not once per card.`, 'sign_in', undefined, [{ url: viewer, label: 'Sign in' }]);
-                                settle({ asked: true, where: viewer });
-                            },
-                            onNote: pageNote,
-                        })
-                            .then(async (r) => {
-                            if (signCwd)
-                                signInPending.delete(signCwd);
-                            if (!r.ok || !r.session) {
-                                log('warn', `sign-in for "${part}" did not finish: ${r.why ?? 'nothing was saved'}`);
-                                /* Say so ON THE CARD. The flag already raised carries a link to a viewer
-                                   that is now dead, and a person coming back to it an hour later would find
-                                   a page that cannot connect and no indication why — which reads as the
-                                   feature being broken rather than as a window having closed. */
-                                void flagCard(ref, `The sign-in for ${url} expired before anyone did it — the link in the ` +
-                                    `earlier request no longer works.\n\n${why}\n\nNothing is broken: ask ` +
-                                    `the agent to try again and a fresh sign-in is offered.`, 'sign_in');
-                                settle({ asked: false, why: r.why ?? 'nothing was saved' });
-                                return;
-                            }
-                            /* Awaited, and the failure is handled. Sessions live only in FlareDeck now —
-                               there is no copy on this machine — so a failed write means the sign-in is
-                               GONE. Announcing "Signed in" and resuming the card would wake an agent that
-                               meets the same wall and asks again: a loop that reads as the feature being
-                               broken rather than as one write having failed. */
-                            const saved = await rememberSignInNow(config.repo, part, r.session, (t) => log('tool', `sign-in: ${t}`));
-                            if (!saved.ok) {
-                                log('warn', `sign-in for "${part}" completed but was NOT saved: ${saved.message ?? 'no reason given'}`);
-                                void flagCard(ref, `Someone signed in to ${url}, but the session could not be saved to FlareDeck ` +
-                                    `(${saved.message ?? 'no reason given'}). Credentials are kept only in FlareDeck, ` +
-                                    `so nothing was retained here and the sign-in has been lost.\n\n${why}\n\n` +
-                                    `Once FlareDeck is reachable, ask the agent to try again.`, 'sign_in');
-                                settle({ asked: false, why: saved.message ?? 'the session could not be saved' });
-                                return;
-                            }
-                            const site = saved.id;
-                            log('tool', `signed in — kept for ${site}; every card on this project opens straight in`);
+                    requestSignIn: requestSignIn({
+                        card: () => onCard,
+                        relayService: process.env['FLAREDECK_RELAY_URL'] ?? config.agentServiceUrl,
+                        appBase: process.env['FLAREDECK_APP_URL'] ?? 'https://app.flaredeck.app',
+                        token: () => opts.auth(),
+                        ensureBrowser: () => ensureBrowser((t) => log('tool', `browser: ${t}`)),
+                        runSignIn: async (o) => {
+                            const { chromium } = await import('playwright-core');
+                            const { signInSession } = await import('./signin.js');
+                            const { HEADLESS_FULL } = await import('./browser.js');
+                            return signInSession({ ...o, launch: () => chromium.launch(HEADLESS_FULL) });
+                        },
+                        remember: async (part, session) => {
+                            const { rememberSignInNow } = await import('./browser.js');
+                            return rememberSignInNow(config.repo, part, session, (t) => log('tool', `sign-in: ${t}`));
+                        },
+                        flag: (ref, reason, links) => void flagCard(ref, reason, 'sign_in', undefined, links),
+                        clearFlag: async (ref) => {
                             await callFlaredeckTool(config.mcpUrl, await opts.auth(), 'clear-needs-human', {
-                                card_id: card.code || card.card,
-                                ...(card.board ? { board_id: card.board } : {}),
-                            }).catch((e) => log('warn', `could not clear needs-human: ${e instanceof Error ? e.message : String(e)}`));
-                            parked.delete(card.card);
-                            resumeParked(card, `Signed in. The session is kept for ${site}, so open_page opens the app signed ` +
-                                `in from now on. Carry on with what you were going to check: ${why}`);
-                        })
-                            .catch((e) => {
-                            const why2 = e instanceof Error ? e.message : String(e);
-                            log('warn', `sign-in for "${part}" failed: ${why2}`);
-                            settle({ asked: false, why: why2 });
-                        });
-                        return ready;
-                    },
+                                card_id: ref.code || ref.card, ...(ref.board ? { board_id: ref.board } : {}),
+                            });
+                        },
+                        resume: (card, text) => { parked.delete(card.card); resumeParked({ ...card, cwd }, text); },
+                        pending: (() => {
+                            // Held up while the person has not signed in yet — see signInPending.
+                            let at;
+                            return { start: () => { at = turnCwd; if (at)
+                                    signInPending.set(at, Date.now()); }, done: () => { if (at)
+                                    signInPending.delete(at); } };
+                        })(),
+                        newId: () => `sgn_${randomBytes(9).toString('base64url')}`,
+                        log,
+                    }),
                 }
                 : {}),
         });
@@ -3810,95 +3568,248 @@ export async function serve(opts) {
          * made about its card that had not been made at all.
          */
         if (forACard && !needsRunning) {
-            log('tool', isManager
+            log('tool', profile.manage
                 ? 'environment not started — a manager answers from the card and its teams\' machines; call start_environment if you need this project running'
                 : prepared
                     ? 'environment not started — this card does not look like it needs one'
                     : 'environment not started — nothing judged whether it is needed; call start_environment if it is');
         }
-        // A lead's sweep is a JOB, not a nudge: clear the ready column by running the team. A nudge
-        // got one look and "nothing to do"; a goal keeps the lead going, turn after turn, until the
-        // board itself says it is done — proven by get-portfolio, not by the lead's own say-so.
-        // Nothing ready means nothing to dispatch: a goal there is only turns spent proving an empty
-        // list empty. ['?'] is "could not tell", which keeps the goal.
-        const leadGoal = isLead && event.event === 'sweep' && process.env['FLAREDECK_AGENT_LEAD_GOAL'] !== '0' &&
-            (await readyToHand()).length > 0
-            ? LEAD_SWEEP_GOAL
-            : undefined;
-        if (leadGoal)
-            log('tool', 'sweep with a goal: clear the ready column by dispatching (≤8 turns)');
+        return { forACard, checks, needsRunning, declaredSites, web, envTools, eyes, envNow: () => env, alongsideNotes: alongside.notes };
+    }
+    /**
+     * A turn, running: every event it emits, as it emits it. The pane, the ledger and the live feed
+     * are told; the handover log notes what changed; a turn fighting the tools is told to stop and
+     * ask; one near the end of its context is asked to wrap up; a session whose FlareDeck server did
+     * not connect is refused. Returns how big the context got, the final text, and any error.
+     */
+    async function watchTurn(run, t) {
+        const { event, key, isAssistantChat, prepared, usage, struggling } = t;
+        let turnTokens = 0;
+        let nudged = false;
+        let doneText = '';
+        let runError = null;
+        try {
+            for await (const out of run.events) {
+                status.observe(out);
+                if (out.kind === 'done' && !out.ok)
+                    doneText = String(out.result ?? '');
+                usage.observe(out);
+                if (out.kind === 'spend') {
+                    const spent = out;
+                    void geminiSpend?.record(spent).then((r) => {
+                        if (!r) {
+                            log('warn', 'gemini: could not report this run\'s tokens to FlareDeck — its spend is not counted');
+                            return;
+                        }
+                        // The tokens behind the dollars, so a figure that looks wrong can be checked (16 Oct).
+                        const k = (n) => `${Math.round(n / 1000)}k`;
+                        log('tool', `${spendLine(r.usd, r.status)} · ${spent.model}: ${k(spent.prompt)} in (${k(spent.cached)} cached), ${k(spent.output)} out, ${k(spent.thinking)} thinking${r.known_price ? '' : ` · no price set for ${spent.model}, charged at the dearest`}`);
+                        if (r.status.over && !geminiOver)
+                            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) {
+                        log('warn', `${struggling.why()} this turn — telling it to stop and ask`);
+                        const heard = await run.steer(stepBack).catch(() => false);
+                        // An engine that cannot be steered gets stopped instead: letting it carry on is how a
+                        // turn becomes twenty minutes of working around a guard.
+                        if (!heard) {
+                            log('warn', 'cannot steer this engine — ending the turn');
+                            await run.stop().catch(() => { });
+                        }
+                        if (tag)
+                            void tellLeadItIsStuck(tag, struggling.refusals());
+                    }
+                }
+                state.tasks = status.snapshot().tasks;
+                // 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 (isAssistantChat)
+                    chat.observe(out);
+                if (out.kind === 'task')
+                    log('tool', out.state === 'started' ? `background: ${out.text}` : `background ${out.state}: ${out.text.slice(0, 160)}`);
+                if (out.kind === 'text')
+                    log(event.event === 'ask' ? 'answer' : 'say', out.text);
+                else if (out.kind === 'tool')
+                    log('tool', out.name);
+                // A changed plan is the most informative thing an agent emits, so it is pushed at once
+                // rather than waiting for the timer.
+                else if (out.kind === 'todo') {
+                    log('todo', out.text);
+                    void report();
+                }
+                // The plan replaces the previous one — TodoWrite always sends the whole list.
+                else if (out.kind === 'plan') {
+                    state.plan = out.items;
+                    state.tasks = {
+                        done: out.items.filter((t) => t.status === 'completed').length,
+                        total: out.items.length,
+                    };
+                    void report();
+                }
+                else if (out.kind === 'ready') {
+                    // Kept only where it can be picked up again. An Antigravity conversation dies with the run
+                    // that held it, and resuming one that is gone used to start a fresh conversation with a
+                    // follow-up message and no card: the handover "that is this card done", sent after a
+                    // startup check, had agy searching env and old transcripts for which card it was on — and
+                    // a resumed turn skips intake, so it never got sized off the small model either.
+                    if (out.sessionId && engine.capabilities.resumeSession) {
+                        sessions.set(key, out.sessionId);
+                        if (key === ASSISTANT_KEY)
+                            chat.keep(out.sessionId);
+                    }
+                    // The preflight proved the server answers; this proves the SESSION got it. The SDK will
+                    // start the model with a server still 'pending' or 'needs-auth' and list its tools from
+                    // memory, so a count alone is not enough — the status has to say connected. Refuse the
+                    // turn otherwise: the event stays queued and comes back once the tools are really there.
+                    const fd = out.mcp.find((s) => s.name === config.mcpServerName);
+                    log('tool', `session: FlareDeck ${fd?.status ?? 'absent'} · ${out.tools.length} tools · ${out.permissionMode}`);
+                    if (!fd || fd.status !== 'connected' || out.tools.length === 0) {
+                        throw new CouldNotWork(`this session's FlareDeck server is ${fd?.status ?? 'absent'}, so the card cannot be read — leaving the event queued`);
+                    }
+                }
+                else if (out.kind === 'usage') {
+                    turnTokens = out.contextTokens;
+                    if (!nudged && turnTokens >= CONTEXT_WRAP_UP_TOKENS && liveRun) {
+                        nudged = true;
+                        log('warn', `context at ${Math.round(turnTokens / 1000)}k — asking it to wrap up before the window fills`);
+                        const wrapUpText = `Your context is at ${Math.round(turnTokens / 1000)}k tokens and will be compacted soon, which loses detail. ` +
+                            'Finish the step you are on, then stop: comment on the card with where things stand, put anything half-done ' +
+                            'and anything that did NOT work into set-card-notes, and end the turn. A fresh session will pick the card up from the note.';
+                        void liveRun.steer(wrapUpText);
+                    }
+                }
+                else if (out.kind === 'compacted')
+                    log('warn', 'the SDK compacted this session mid-turn — detail before this point is summarised, not kept');
+                else if (out.kind === 'done') {
+                    if (!out.ok)
+                        log('warn', 'the turn did not finish cleanly');
+                    for (const d of out.denials ?? [])
+                        log('warn', `declined by the permission check: ${d.tool}${d.what ? ` ${d.what}` : ''}${d.why ? ` — because: ${d.why}` : ''}`);
+                    if (out.contextTokens)
+                        turnTokens = out.contextTokens;
+                    // The number the intake step is meant to move: how big this turn's context got.
+                    if (turnTokens)
+                        log('tool', `turn: ${Math.round(turnTokens / 1000)}k context${prepared?.size ? ` · ${prepared.size} work` : ''}`);
+                }
+            }
+        }
+        catch (e) {
+            runError = e;
+        }
+        return { turnTokens, doneText, runError };
+    }
+    async function handle(input) {
+        const admitted = await admit(input);
+        if (!admitted)
+            return;
+        const { isAssistantChat, queuedBehind } = admitted;
+        const placed = await placeTurn(admitted.event, isAssistantChat);
+        if (!placed)
+            return;
+        const { event, key, where, chosen, repo, startFrom, tree, cwd, leadWithoutCode, repoChoiceNote, pickedUp } = placed;
+        // FlareDeck must be there before the model is. Without it the turn cannot read the card,
+        // comment, or ask for help — and it would still run, answer fluently that it could not do
+        // the work, and be acknowledged. The card would be gone. So: no FlareDeck, no turn.
+        // The plan for this run is asked for now, alongside the check, instead of after everything
+        // else: one more round trip the person was waiting on. Awaited where it is used.
+        const subsEarly = subscriptionsForAgent(config.mcpUrl, () => opts.auth(), (t) => log('tool', t));
+        const planEarly = subsEarly.then((sc) => (sc ? sc.choose(failedPlans.get(event.id) ?? []) : null)).catch(() => null);
+        const check = await preflightFlaredeck(config.mcpUrl, await opts.auth());
+        if (!check.ok) {
+            log('warn', check.reason);
+            throw new CouldNotWork(`${check.reason} — event left queued`);
+        }
+        log('tool', `FlareDeck reachable · ${check.discovered.tools.length} tools`);
+        // Served from in here for this turn: a fresh token per call, so a card that outlives the
+        // token's hour keeps its tools, and nothing on this machine can shadow the server by name.
+        // The gate on calling a card finished: it must have commits of its own, published. Checked
+        // here rather than trusted, because a turn that produced nothing still reports confidently.
+        const gate = finishGate({
+            ...(opts.deck ? { card: (ref) => opts.deck.card(ref) } : {}),
+            cardRef: () => tag || event.cardCode || event.cardKey || '',
+            cardCode: () => event.cardCode || tag,
+            tree,
+            startFrom,
+            oversees: profile.oversees,
+            lead: leadId ? { id: leadId, name: leadName } : null,
+            selfId,
+            handedBack,
+            handToLead: async (code, message) => {
+                const token = await opts.auth();
+                await callFlaredeckTool(config.mcpUrl, token, 'assign-card', { card_id: code, assignee: leadId });
+                await callFlaredeckTool(config.mcpUrl, token, 'send-message', { to: leadId, message });
+            },
+            log,
+        });
+        // A turn woken by a message says "a message from JARVIS" for as long as it runs, even while
+        // it is plainly working a card. The card tools name the card; this takes it from there, and
+        // only when the turn had none of its own.
+        // Ground truth for the footer on anything this agent says. Null without a worktree: there is
+        // no branch to report on, and a footer saying "nothing committed" would be misleading rather
+        // than informative.
+        const savedSoFar = async () => {
+            if (!tree)
+                return null;
+            const { commits, pushed, branch, known } = await produced(tree);
+            return { branch, commits, pushed, known };
+        };
+        const noteCard = (code) => {
+            if (!code || tag)
+                return;
+            tag = code;
+            state.working = code;
+        };
+        const flaredeck = flaredeckProxy(config.mcpServerName, config.mcpUrl, opts.auth, check.discovered, (w) => log('warn', w), gate, noteCard, keepTool, savedSoFar, [...myBoards]);
+        const card = await prepareCard(event, key, repo, queuedBehind);
+        if (!card)
+            return;
+        const { resume, prepared } = card;
         /**
-         * Which Claude subscription pays for this run.
+         * Which card this turn is about — including when nobody dispatched it.
          *
-         * Three subscriptions and twenty-odd agents, with daily and weekly caps that trip at
-         * different times, used to mean going round the machines logging in again. FlareDeck holds
-         * the tokens and the ledger now and picks one per run.
+         * This was set only from the event's own cardKey, so a question typed in the pane about a
+         * card had none: the agent had the card, its checkout and its environment, hit a sign-in it
+         * could not pass, and was told "there is no card being worked, so there is nobody to ask
+         * about it". It fell back to leaving a comment, which nobody is notified about. The one
+         * moment the escalation exists for, and it was unavailable.
          *
-         * Not reaching FlareDeck is NOT the same as having nothing left: `machine` means carry on
-         * with whatever this box is logged in as, exactly as before any of this existed. Only
-         * `none` — every subscription genuinely spent or paused — stops the run, and it says when
-         * one frees up rather than failing blankly.
+         * `tag` is the code the turn resolved to — from the event, or from the card a pane question
+         * named. FlareDeck takes a human code wherever it takes a card id, so the code alone is
+         * enough to flag, comment and clear.
          */
-        /* The MCP list, fresh for this session — and a required server that is not connected stops
-           the work here, before a plan is spent on a card that cannot be done properly. */
-        const missingMcp = await refreshMcp();
-        if (missingMcp?.length) {
-            await enterPause(mcpWallFor(missingMcp));
-            return;
-        }
-        const subs = await subsEarly.catch(() => null);
-        const claudePlan = await planEarly;
-        if (claudePlan?.use === 'token') {
-            log('tool', `claude: ${claudePlan.label}`);
-            // On the identity line too, not only in the scrollback: the scrollback moves on, and
-            // "which account is this agent spending" is a thing you glance at, not search for.
-            state.claudeAccount = claudePlan.label;
-            // Measured again once this event is done — see measurePlan.
-            turnPlan = { id: claudePlan.id, label: claudePlan.label, token: claudePlan.token };
-            planOfSession.set(key, claudePlan.token);
-        }
-        // Gemini answers on agy, so spent Claude plans stop it only when Claude is needed — at the
-        // Gemini limit, below.
-        if (claudePlan?.use === 'none' && engine.name !== 'antigravity') {
-            const when = claudePlan.availableAt ? new Date(claudePlan.availableAt).toLocaleString() : 'later';
-            const tried = failedPlans.get(event.id)?.length ?? 0;
-            failedPlans.delete(event.id);
-            /**
-             * Spent, not paused: the harness knows to the minute when a plan comes back — FlareDeck's
-             * answer carries the soonest reset — so it waits for it and carries on by itself. Nobody is
-             * asked to do anything about a clock. Only a fleet with NO reset coming (every plan paused,
-             * which only a person undoes) is flagged.
-             */
-            if (claudePlan.availableAt && claudePlan.availableAt > Date.now()) {
-                const at = claudePlan.availableAt;
-                if (!waitingForPlan.has(event.id)) {
-                    // A little after the reset, so the first request is not refused for being a second early.
-                    const timer = setTimeout(() => {
-                        waitingForPlan.delete(event.id);
-                        log('event', `a Claude subscription is back — resuming ${event.cardCode || event.line}`);
-                        if (enqueue(event, true))
-                            void drain();
-                    }, at - Date.now() + 60_000);
-                    timer.unref?.();
-                    waitingForPlan.set(event.id, timer);
-                }
-                log('warn', `every Claude subscription is spent${tried ? ` (${tried} failed on this turn)` : ''} — waiting, resuming at ${new Date(at).toLocaleTimeString()}`);
-                return;
+        onCard = event.cardKey
+            ? {
+                card: event.cardKey,
+                cwd,
+                ...(event.boardKey ? { board: event.boardKey } : {}),
+                ...(event.cardCode ? { code: event.cardCode } : {}),
             }
-            log('warn', `every Claude subscription is spent or paused${tried ? ` (${tried} failed on this turn)` : ''} — the soonest frees up ${when}`);
-            await flagCard({ card: event.cardKey ?? '', ...(event.boardKey ? { board: event.boardKey } : {}), ...(event.cardCode ? { code: event.cardCode } : {}) }, `I cannot start this card: every Claude subscription in FlareDeck is spent, paused` +
-                `${tried ? ', or just failed on this card' : ''}. ` +
-                `The soonest one frees up ${when}.\n\nNothing is wrong with the card. Add or unpause a ` +
-                `subscription on the Integrations page, or wait for the window to reset.`, 'technical');
+            : tag
+                ? { card: tag, cwd, code: tag, ...(event.boardKey ? { board: event.boardKey } : {}) }
+                : null;
+        job = await publishJob(event, key, tree, cwd, startFrom);
+        const { forACard, checks, needsRunning, declaredSites, web, envTools, eyes, envNow, alongsideNotes } = await bringUpEnvironment(event, tree, cwd, where, prepared);
+        // A lead's sweep is a JOB, not a nudge: clear the ready column by running the team. A nudge
+        // got one look and "nothing to do"; a goal keeps the lead going, turn after turn, until the
+        // board itself says it is done — proven by get-portfolio, not by the lead's own say-so.
+        // Nothing ready means nothing to dispatch: a goal there is only turns spent proving an empty
+        // list empty. ['?'] is "could not tell", which keeps the goal.
+        const leadGoal = profile.dispatch && event.event === 'sweep' && process.env['FLAREDECK_AGENT_LEAD_GOAL'] !== '0' &&
+            (await readyToHand()).length > 0
+            ? LEAD_SWEEP_GOAL
+            : undefined;
+        if (leadGoal)
+            log('tool', 'sweep with a goal: clear the ready column by dispatching (≤8 turns)');
+        const planned = await choosePlan(event, key, subsEarly, planEarly);
+        if (!planned)
             return;
-        }
-        /*
-         * Gemini bills per token, so a workspace sets a dollar limit on it (Integrations → Secrets).
-         * Reached, the turn runs on Claude instead — the same agent, its subscription chosen above —
-         * and Gemini answers again once the limit resets (Cobus, 16 Oct). No Claude to fall back on:
-         * the card waits for the reset, as it would for a spent plan.
-         */
-        let turnEngine = engine;
+        const { subs, claudePlan, turnEngine } = planned;
         /* Helpers (helpers.ts): on by default since 17 Oct — they paid for themselves while measured.
            Off with `helpers: false` in the config or `--no-helpers`. The result of one running in the
            background is typed into THIS turn; if the turn has ended by then, it starts the next one
@@ -3917,46 +3828,16 @@ export async function serve(opts) {
             if (enqueue({ id: `helper-${Date.now()}`, event: 'assigned', cardKey: event.cardKey, cardCode: event.cardCode, ...(event.boardKey ? { boardKey: event.boardKey } : {}), line: `A helper you started on this card finished after your last turn ended:\n${text.slice(0, 6000)}` }))
                 void drain();
         };
-        if (engine.name === 'antigravity') {
-            const spend = await geminiSpend?.status().catch(() => null);
-            if (spend?.over) {
-                if (claudePlan?.use === 'token') {
-                    turnEngine = claudeFallback ??= new (await import('./engine-claude.js')).ClaudeEngine();
-                    if (!geminiOver)
-                        log('warn', `${spend.over.message} — Claude answers until ${new Date(spend.over.until).toLocaleString()}`);
-                    geminiOver = true;
-                }
-                else {
-                    const at = spend.over.until;
-                    if (!waitingForPlan.has(event.id)) {
-                        const timer = setTimeout(() => {
-                            waitingForPlan.delete(event.id);
-                            log('event', `the Gemini limit has reset — resuming ${event.cardCode || event.line}`);
-                            if (enqueue(event, true))
-                                void drain();
-                        }, at - Date.now() + 60_000);
-                        timer.unref?.();
-                        waitingForPlan.set(event.id, timer);
-                    }
-                    log('warn', `${spend.over.message}, and there is no Claude subscription to fall back on — waiting until ${new Date(at).toLocaleString()}`);
-                    return;
-                }
-            }
-            else if (geminiOver && spend) {
-                log('event', 'the Gemini limit has reset — Gemini answers again');
-                geminiOver = false;
-            }
-        }
         const helperSet = helpersOn && turnEngine.name === 'claude' ? helperTools({
             cwd: () => tree?.path ?? cwd,
             ...(claudePlan?.use === 'token' ? { claudeToken: claudePlan.token } : {}),
             // Its own browser, on the same environment the agent's points at.
             browser: () => browserTools({
                 repo: config.repo,
-                endpoints: () => env.endpoints,
+                endpoints: () => envNow().endpoints,
                 ...(web ? { defaultPart: () => web } : {}),
                 sites: () => declaredSites,
-                contract: () => env.contract,
+                contract: () => envNow().contract,
                 cwd,
                 onNote: (t) => log('tool', t),
             }),
@@ -3972,7 +3853,8 @@ export async function serve(opts) {
         }) : null;
         const engineContext = {
             ...(leadGoal ? { goal: leadGoal } : {}),
-            config: { ...config, repo: cwd, ...(isAssistantChat ? { assistantMode: true } : {}) },
+            // Read anywhere the work could need — the agent's folder and its alongside clones — write only here.
+            config: { ...config, repo: cwd, readAlso: [config.repo, join(configDir(), 'services'), ...(tree?.folder ? [tree.folder] : [])], ...(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.
@@ -3989,13 +3871,14 @@ 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.
-            ...(isAssistantChat ? {} : { sandbox: tree ? tree.path : scratchDir() }),
+            // A card folder is written as a whole: every repository in it is the card's.
+            ...(isAssistantChat ? {} : { sandbox: tree ? tree.folder ?? 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) } : {}),
+            ...(job && profile.code ? { publish: async () => publishBranch(job) } : {}),
             standing: standingBrief(!!teamSet, config.style ?? process.env['FLAREDECK_AGENT_STYLE'], isAssistantChat, config.mcpServers, config.trustedScripts),
-            finish: finishGate,
+            finish: gate,
             noteCard,
             keep: keepTool,
             saved: savedSoFar,
@@ -4008,25 +3891,27 @@ export async function serve(opts) {
             ...(prepared?.size ? { size: prepared.size } : {}),
             ...(claudePlan?.use === 'token' ? { claudeToken: claudePlan.token } : {}),
             ...(helpersOn && turnEngine.name === 'antigravity' ? { subagents: true } : {}),
-            tools: {
-                ...(helperSet ? { helpers: helperSet } : {}),
-                ...(job ? { git: { server: gitServer, toolNames: GIT_TOOL_NAMES } } : {}),
+            // What the model can do this turn, by the profile's features: see harness/tools.ts.
+            tools: mountTools({
+                helpers: helperSet,
+                git: { server: gitServer, toolNames: GIT_TOOL_NAMES },
                 // The project's file storage, when a person has set one up for these boards.
-                ...(await turnFileTools(cwd, forACard, event.environment) ?? {}),
-                // Eyes, for any card. They used to be mounted only when the harness had itself started
-                // something, which left an agent working alone unable to get them: no start script meant
-                // no browser AND no mention of one, so it could not know that writing the script it is
-                // perfectly able to write was the thing standing between it and seeing its own change.
-                // The endpoints are read through a getter, so something the agent starts mid-turn counts.
+                files: await turnFileTools(cwd, forACard, event.environment),
+                // Eyes, for any card, read through a getter so something the agent starts mid-turn counts.
                 browser: eyes,
                 env: envTools,
                 team: teamSet,
                 flaredeck,
                 runs: runsSet,
                 schedules: schedulesSet,
-                ...((config.trustedScripts ?? []).length ? { scripts: scriptsSet } : {}),
-                ...(releaseSet && (isLead || isManager || soloWorker || namedReleaser || event.hotfix === true) ? { release: releaseSet } : {}),
-            },
+                scripts: scriptsSet,
+                release: releaseSet,
+            }, {
+                profile,
+                hasJob: !!job,
+                mayRelease: releasesOwnCards(profile, soloWorker) || namedReleaser || event.hotfix === true,
+                hasScripts: (config.trustedScripts ?? []).length > 0,
+            }),
             guard: {
                 ...guard,
                 PostToolUse: [...(guard.PostToolUse ?? []), mcpSignInHook],
@@ -4037,23 +3922,30 @@ export async function serve(opts) {
         // Before the agent believes a single thing the environment tells it: is this environment
         // actually its own? A front end on an assumed port reaches another worktree's API and answers
         // perfectly, which is the one failure here that looks like success.
-        const wrongEnv = tree && env.ran ? await crossWired(env.endpoints, tree.path) : [];
+        const wrongEnv = tree && envNow().ran ? await crossWired(envNow().endpoints, tree.path) : [];
         for (const w of wrongEnv)
             log('warn', w);
         // A direct message: the conversation's last ten messages in full, so the agent answers from
         // them instead of spending its first step on read-messages (the event line is shortened).
         const thread = event.event === 'message' && event.actorKey ? await recentThread(event.actorKey) : '';
-        const brief = waitedNote(event) + prompt(event, isLead) + thread + intakeText(prepared) +
+        // What this agent keeps on the card's repositories — its own notes, 400 words each, loaded only
+        // with cards in them (harness/repo-notes.ts).
+        const notes = tree ? await repoNotes([chosen?.origin ?? '', ...(tree.companions ?? []).map((c) => c.repository)], async (q) => {
+            const tid = tenantFromToken(await opts.auth());
+            const r = await fetch(`${new URL(config.mcpUrl).origin}/api/v1/${encodeURIComponent(tid ?? '')}/agent/memory?repositories=${encodeURIComponent(q.join(','))}`, { headers: { authorization: `Bearer ${await opts.auth()}` }, signal: AbortSignal.timeout(10_000) });
+            return r.ok ? (await r.json()).repositories ?? {} : {};
+        }).catch(() => '') : '';
+        const brief = waitedNote(event) + prompt(event, profile.dispatch) + thread + intakeText(prepared) +
             workspaceBrief(config.repo, await checkouts(config.repo, scope), chosen) +
-            worktreeBrief(tree) + repoChoiceNote + (await resumeBrief(event.cardCode || event.cardKey || '', tree)) +
+            worktreeBrief(tree) + (tree ? folderBrief(tree) : '') + notes + repoChoiceNote + (await resumeBrief(event.cardCode || event.cardKey || '', tree)) +
             unclearBrief(prepared?.jev ?? null, leadName) + preflightBrief(checks) + backBrief(event) +
-            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 : '') : '') +
-            (isAssistantChat ? assistantBrief(person) : '') +
+            // What this kind of agent is told on top of the card: see roleBriefs in harness/prompt.ts.
+            roleBriefs(profile, { event, chat: isAssistantChat, person: chat.person(), leadWithoutCode, queuedBehind }) +
             // 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) +
+            environmentBrief(envNow(), cwd, needsRunning) + notStartedBrief(forACard && !needsRunning, cwd) +
+            (alongsideNotes.length && tree?.folder ? `\n\n## Running from your folder\n\n${alongsideNotes.map((n) => `  · ${n}`).join('\n')}\n` : '') +
+            (alongsideNotes.length && !tree?.folder ? `\n\n## Running beside this card\n\n${alongsideNotes.map((n) => `  · ${n}`).join('\n')}\n\nYou may READ their code — and every repository in ${config.repo} — to understand how your change meets theirs; change only your own checkout.\n` : '') +
+            browserBrief(envNow().endpoints, declaredSites, forACard, web) +
             (wrongEnv.length
                 ? `\n\nSTOP — the environment that started is not yours:\n${wrongEnv.map((w) => `  · ${w}`).join('\n')}\n\n` +
                     `Anything you test against it tells you about another card's code, and it will answer ` +
@@ -4065,7 +3957,7 @@ export async function serve(opts) {
         liveRun = run;
         thisRun = run;
         if (isAssistantChat)
-            liveFeed?.start(String(event.message ?? event.line ?? '').split('\n').filter(Boolean).pop() ?? '');
+            chat.turnStarted(event);
         // 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.
         const mcpTokens = () => JSON.stringify((config.mcpServers ?? []).map((m) => [m.name, m.token ?? '']));
@@ -4087,191 +3979,32 @@ export async function serve(opts) {
         renewTimer.unref();
         // An agent that has started fighting the tools is not going to stop on its own.
         const struggling = watchForDesperation();
-        /**
-         * One cap is usually seen two or three times in a run: the structured `rate_limit_event`
-         * (which knows the window and the reset), then the error on the assistant message and the
-         * result text (which know neither). Reporting all of them filed an `unknown` window with a
-         * guessed five-hour block on top of the real one — keeping a plan out hours past its actual
-         * reset. Once a run has reported a named window, the anonymous echoes are dropped.
-         */
-        let spentNamed = false;
-        let spentAny = false;
-        const spentReports = [];
-        let doneText = '';
-        let runError = null;
-        try {
-            for await (const out of run.events) {
-                status.observe(out);
-                if (out.kind === 'done' && !out.ok)
-                    doneText = String(out.result ?? '');
-                if (out.kind === 'limits' && claudePlan?.use === 'token') {
-                    /* Reported, never interpreted here. 'allowed_warning' arrives while the plan is still
-                       working — treating it as spent would retire every subscription at about half capacity
-                       and leave the agents with nothing while each account still had headroom. */
-                    if (out.spent) {
-                        const named = !!out.window && out.window !== 'unknown';
-                        spentAny = true;
-                        if (named || !spentNamed) {
-                            spentNamed ||= named;
-                            spentReports.push(subs?.spent(claudePlan.id, out.window, out.resetsAt, out.why ?? `hit during ${event.cardCode ?? event.cardKey ?? 'a run'}`) ?? Promise.resolve());
-                            log('warn', `claude: ${claudePlan.label} hit its ${out.window ?? 'usage'} limit (${out.source ?? 'unknown signal'})`);
-                        }
-                    }
-                    else if (out.window && typeof out.utilization === 'number') {
-                        turnSawUsage = true;
-                        void subs?.seen(claudePlan.id, out.window, out.utilization, out.resetsAt);
-                    }
-                }
-                if (out.kind === 'spend') {
-                    const spent = out;
-                    void geminiSpend?.record(spent).then((r) => {
-                        if (!r) {
-                            log('warn', 'gemini: could not report this run\'s tokens to FlareDeck — its spend is not counted');
-                            return;
-                        }
-                        // The tokens behind the dollars, so a figure that looks wrong can be checked (16 Oct).
-                        const k = (n) => `${Math.round(n / 1000)}k`;
-                        log('tool', `${spendLine(r.usd, r.status)} · ${spent.model}: ${k(spent.prompt)} in (${k(spent.cached)} cached), ${k(spent.output)} out, ${k(spent.thinking)} thinking${r.known_price ? '' : ` · no price set for ${spent.model}, charged at the dearest`}`);
-                        if (r.status.over && !geminiOver)
-                            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) {
-                        log('warn', `${struggling.why()} this turn — telling it to stop and ask`);
-                        const heard = await run.steer(stepBack).catch(() => false);
-                        // An engine that cannot be steered gets stopped instead: letting it carry on is how a
-                        // turn becomes twenty minutes of working around a guard.
-                        if (!heard) {
-                            log('warn', 'cannot steer this engine — ending the turn');
-                            await run.stop().catch(() => { });
-                        }
-                        if (tag)
-                            void tellLeadItIsStuck(tag, struggling.refusals());
-                    }
-                }
-                state.tasks = status.snapshot().tasks;
-                // 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 (isAssistantChat && liveFeed) {
-                    if (out.kind === 'text' && !out.sub)
-                        liveFeed.add('text', out.text);
-                    else if (out.kind === 'tool' && !out.sub)
-                        liveFeed.add('tool', out.name);
-                    else if (out.kind === 'task')
-                        liveFeed.add('note', out.state === 'started' ? `Started in the background: ${out.text}` : `Background work ${out.state}: ${out.text}`);
-                    else if (out.kind === 'done')
-                        liveFeed.idle();
-                }
-                if (out.kind === 'task')
-                    log('tool', out.state === 'started' ? `background: ${out.text}` : `background ${out.state}: ${out.text.slice(0, 160)}`);
-                if (out.kind === 'text')
-                    log(event.event === 'ask' ? 'answer' : 'say', out.text);
-                else if (out.kind === 'tool')
-                    log('tool', out.name);
-                // A changed plan is the most informative thing an agent emits, so it is pushed at once
-                // rather than waiting for the timer.
-                else if (out.kind === 'todo') {
-                    log('todo', out.text);
-                    void report();
-                }
-                // The plan replaces the previous one — TodoWrite always sends the whole list.
-                else if (out.kind === 'plan') {
-                    state.plan = out.items;
-                    state.tasks = {
-                        done: out.items.filter((t) => t.status === 'completed').length,
-                        total: out.items.length,
-                    };
-                    void report();
-                }
-                else if (out.kind === 'ready') {
-                    // Kept only where it can be picked up again. An Antigravity conversation dies with the run
-                    // that held it, and resuming one that is gone used to start a fresh conversation with a
-                    // follow-up message and no card: the handover "that is this card done", sent after a
-                    // startup check, had agy searching env and old transcripts for which card it was on — and
-                    // a resumed turn skips intake, so it never got sized off the small model either.
-                    if (out.sessionId && engine.capabilities.resumeSession) {
-                        sessions.set(key, out.sessionId);
-                        if (key === ASSISTANT_KEY)
-                            saveAssistantSession(assistantSessionFile, out.sessionId);
-                    }
-                    // The preflight proved the server answers; this proves the SESSION got it. The SDK will
-                    // start the model with a server still 'pending' or 'needs-auth' and list its tools from
-                    // memory, so a count alone is not enough — the status has to say connected. Refuse the
-                    // turn otherwise: the event stays queued and comes back once the tools are really there.
-                    const fd = out.mcp.find((s) => s.name === config.mcpServerName);
-                    log('tool', `session: FlareDeck ${fd?.status ?? 'absent'} · ${out.tools.length} tools · ${out.permissionMode}`);
-                    if (!fd || fd.status !== 'connected' || out.tools.length === 0) {
-                        throw new CouldNotWork(`this session's FlareDeck server is ${fd?.status ?? 'absent'}, so the card cannot be read — leaving the event queued`);
-                    }
-                }
-                else if (out.kind === 'usage') {
-                    turnTokens = out.contextTokens;
-                    if (!nudged && turnTokens >= CONTEXT_WRAP_UP_TOKENS && liveRun) {
-                        nudged = true;
-                        log('warn', `context at ${Math.round(turnTokens / 1000)}k — asking it to wrap up before the window fills`);
-                        const wrapUpText = `Your context is at ${Math.round(turnTokens / 1000)}k tokens and will be compacted soon, which loses detail. ` +
-                            'Finish the step you are on, then stop: comment on the card with where things stand, put anything half-done ' +
-                            'and anything that did NOT work into set-card-notes, and end the turn. A fresh session will pick the card up from the note.';
-                        void liveRun.steer(wrapUpText);
-                    }
-                }
-                else if (out.kind === 'compacted')
-                    log('warn', 'the SDK compacted this session mid-turn — detail before this point is summarised, not kept');
-                else if (out.kind === 'done') {
-                    if (!out.ok)
-                        log('warn', 'the turn did not finish cleanly');
-                    for (const d of out.denials ?? [])
-                        log('warn', `declined by the permission check: ${d.tool}${d.what ? ` ${d.what}` : ''}${d.why ? ` — because: ${d.why}` : ''}`);
-                    if (out.contextTokens)
-                        turnTokens = out.contextTokens;
-                    // The number the intake step is meant to move: how big this turn's context got.
-                    if (turnTokens)
-                        log('tool', `turn: ${Math.round(turnTokens / 1000)}k context${prepared?.size ? ` · ${prepared.size} work` : ''}`);
-                }
-            }
-        }
-        catch (e) {
-            runError = e;
-        }
+        // What this turn's Claude plan reports to the ledger, and whether it must run again on another.
+        const usage = planUsage({
+            plan: claudePlan?.use === 'token' ? { id: claudePlan.id, label: claudePlan.label } : null,
+            subs, failed: failedPlans, eventId: event.id,
+            during: event.cardCode ?? event.cardKey ?? 'a run',
+            log, onSeen: () => { turnSawUsage = true; },
+        });
+        const { turnTokens, doneText, runError } = await watchTurn(run, { event, key, isAssistantChat, prepared, usage, struggling });
         clearInterval(renewTimer);
         liveRun = null;
         if (isAssistantChat)
-            void liveFeed?.end();
-        /**
-         * The plan failed, not the work: switch plans and run this event again, now.
-         *
-         * Two causes, told apart because they are fixed differently. A spent window is already filed
-         * above (awaited here, so `choose` sees it). A rejected token — "401 Invalid bearer token",
-         * a mis-pasted or revoked setup-token — is not capacity and is not filed as spent; it is
-         * excluded for this event, and says plainly that the token needs replacing.
-         *
-         * The retry resumes the same session, so work already done in the turn is not lost; it costs
-         * the prompt cache, which is the price of carrying on at all.
-         */
-        if (claudePlan?.use === 'token') {
-            const said = `${runError instanceof Error ? runError.message : runError ?? ''} ${doneText}`;
-            const rejected = /API Error: 401|invalid bearer token|OAuth token has expired|OAuth token (was )?revoked/i.test(said);
-            if (rejected || spentAny) {
-                await Promise.allSettled(spentReports);
-                const tried = [...(failedPlans.get(event.id) ?? []), claudePlan.id];
-                if (rejected) {
-                    log('warn', `claude: ${claudePlan.label} — its token was rejected. Replace it on Integrations → Secrets.`);
-                }
-                if (tried.length <= MAX_PLAN_SWITCHES) {
-                    failedPlans.set(event.id, tried);
-                    throw new RetryOnAnotherPlan(`${claudePlan.label} ${rejected ? 'rejected its token' : 'is at its limit'} — switching subscription and trying again`);
-                }
-                failedPlans.delete(event.id);
-            }
-        }
-        failedPlans.delete(event.id);
+            chat.turnEnded();
+        // A plan that hit its limit or had its token rejected: the event runs again on another (harness/plan-usage.ts).
+        await usage.settle(runError, doneText);
         if (runError)
             throw runError;
+        await afterTurn({ event, key, cwd, tree, chosen, turnTokens, isAssistantChat });
+    }
+    /**
+     * A turn, last stage: what happens to its session now. An assistant's conversation and a pane
+     * question's session are kept; a scheduled run's and a message's end; a card's stays warm for the
+     * next event — unless the card is finished (its checkout released, the handover written) or the
+     * session has grown past the point where a fresh start beats carrying on.
+     */
+    async function afterTurn(t) {
+        const { event, key, cwd, tree, chosen, turnTokens, isAssistantChat } = t;
         // 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 (isAssistantChat)
@@ -4312,7 +4045,9 @@ export async function serve(opts) {
                 const c = await opts.deck?.card(event.cardCode || event.cardKey);
                 const finished = String(c?.lane?.type ?? '').toLowerCase() === 'done' || c?.done === true;
                 if (finished) {
-                    const { removed, why } = await releaseWorktree(chosen.path, key, (t) => log('tool', t));
+                    const { removed, why } = tree.folder
+                        ? await releaseCardFolder(tree, key, (t) => log('tool', t))
+                        : await releaseWorktree(chosen.path, key, (t) => log('tool', t));
                     if (!removed && why !== 'there was no worktree') {
                         log('warn', `${event.cardCode || key}: kept its checkout — ${why}`);
                     }
@@ -4382,7 +4117,7 @@ export async function serve(opts) {
         // A worker whose card was handed on writes nothing: the notes are the new holder's now. Only
         // for an unfinished card — a finished one has just gone to the lead, and FlareDeck still takes
         // that last note. Leads and managers may write on any card, so theirs always runs.
-        if (!done && leadId && !isLead && !isManager && opts.deck) {
+        if (!done && leadId && !profile.oversees && opts.deck) {
             const card = await opts.deck.card(key).catch(() => null);
             if (cardWentElsewhere(card, selfId)) {
                 log('tool', `${card?.code || key}: now ${card?.assigned_to?.name || 'someone else'}'s card — no handover note from me`);
@@ -4516,7 +4251,7 @@ export async function serve(opts) {
             }
             // Paused: nothing is worked. Acknowledged, because its cards went back to the lead and the
             // lead decides what happens to them; carrying a backlog through a pause would replay it.
-            if (paused) {
+            if (pause.paused()) {
                 log('tool', `paused — left for the lead: ${event.line}`);
                 await stream.ack([event.id]);
                 beat();
@@ -4527,10 +4262,10 @@ 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 && !assistantCard(event)) {
-                const why = assistantIgnores(event, person?.uid ?? null);
+            if (profile.chat && !assistantCard(event)) {
+                const why = chat.ignores(event);
                 if (why) {
-                    log('event', `${event.cardCode || event.event}: ${why} — not for ${person?.name ?? 'anyone'}'s assistant`);
+                    log('event', `${event.cardCode || event.event}: ${why} — not for ${chat.person()?.name ?? 'anyone'}'s assistant`);
                     await stream.ack([event.id]);
                     beat();
                     continue;
@@ -4539,9 +4274,9 @@ export async function serve(opts) {
                 // Set from the turn's closure, which the compiler cannot see from this loop.
                 const run = liveRun;
                 if (run) {
-                    const heard = await run.steer(midTurnMessage(event, person?.name ?? 'your person'), []).catch(() => false);
+                    const heard = await run.steer(chat.midTurn(event), []).catch(() => false);
                     if (heard !== false) {
-                        log('event', `${person?.name ?? 'your person'}: ${String(event.message ?? event.line ?? '').slice(0, 120)} — passed into the running turn`);
+                        log('event', `${chat.person()?.name ?? 'your person'}: ${String(event.message ?? event.line ?? '').slice(0, 120)} — passed into the running turn`);
                         await stream.ack([event.id]);
                         beat();
                         continue;
@@ -4587,8 +4322,8 @@ export async function serve(opts) {
         // that never arrives leaves the agent looking alive to everyone reading FlareDeck.
         await report();
         ui?.stop();
-        if (restarting && restartTo)
-            relaunchSelf(restartTo);
+        if (restarter.relaunchTo())
+            relaunchSelf(restarter.relaunchTo());
     }
 }
 /**
@@ -4607,23 +4342,6 @@ function relaunchSelf(version) {
         execve(process.execPath, args, nextEnv);
     void import('./relaunch.js').then(async ({ runChild }) => process.exit(await runChild(process.execPath, args.slice(1), nextEnv)));
 }
-/**
- * What the agent is actually asked.
- *
- * The event's own one-line rendering is the instruction — it already says what happened and to
- * whom — with only enough added to make clear that acting is expected and that stopping quietly
- * is not an option.
- */
-/** What a pull request should target — the repo's own default, not a guess. */
-/**
- * A few words for the pane from a needs-human reason: its first sentence, without a leading
- * "1." — a reason written as a numbered list was shown as "waiting on a person (1)".
- */
-export function parkLabel(reason) {
-    const plain = reason.replace(/\*\*/g, '').replace(/^[\s#*>-]*(?:\d+[.)]\s*)?/, '');
-    const first = plain.split(/(?<=[a-z0-9)])[.?!](?:\s|$)|\n/i)[0] ?? '';
-    return first.trim().slice(0, 60) || 'an agent asked for help';
-}
 const SIZE_RANK = { small: 0, medium: 1, large: 2 };
 async function baseBranch(cwd) {
     const { spawn } = await import('node:child_process');
@@ -4635,148 +4353,10 @@ async function baseBranch(cwd) {
         c.on('error', () => resolve('main'));
     });
 }
-/**
- * What a lead's sweep must achieve, as a `/goal` condition (under 4000 characters). Judged by a
- * small model from the transcript alone, so the proof has to be IN the transcript: a final
- * get-portfolio, quoted. Bounded, because a column that cannot be emptied (no free worker, every
- * card blocked) must end in reasons, not in a loop.
- */
-// One list, named once: what get-portfolio (state todo) returns. It said "the Ready For Dev lane"
-// and then judged by get-portfolio's todo list, which also holds cards in other todo-type lanes;
-// JARVIS reported "0 in Ready For Dev" turn after turn, never matching, to the 8-turn limit.
-/**
- * The cards in a compact get-portfolio listing that nobody holds — what a lead can actually hand
- * out. A card already assigned to a person or an agent is theirs: counting those made every
- * sweep a dispatch job with nothing to dispatch (HR Goat's pool held eight cards, six of them
- * Cobus's and two the lead's own, and JARVIS was set a goal about them every ten minutes).
- */
-export function unownedCards(listing) {
-    const out = new Set();
-    for (const line of listing.split('\n')) {
-        const m = /^- \[[a-z_]+\] ([A-Z][A-Z0-9]*-\d+)\b.* — owner=(\S+)/.exec(line);
-        if (m && m[2] === '\u2014')
-            out.add(m[1]);
-    }
-    return [...out];
-}
 /** Does the harness bring the project up before this turn? What intake judged — and never for a manager. */
 export function wantsEnvironment(manager, needsRunning) {
     return !manager && (needsRunning ?? 0) >= 0.5;
 }
-export const LEAD_SWEEP_GOAL = 'Every card that get-portfolio (state todo) lists for your boards has been dealt with: handed to ' +
-    'a worker that reports to you and is free, with assign-card, or left where it is with a one-line ' +
-    'reason it must wait (no free worker, blocked, waiting on a person). You dispatch; you do not ' +
-    'build cards yourself. The goal is met when your most recent turn called get-portfolio with ' +
-    'state todo and you quoted how many cards it listed and, for each one still unassigned, its ' +
-    'one-line reason. One call is enough: do not call get-portfolio again to re-check a list that ' +
-    'has not changed. The harness ends this after 8 turns whatever the state of the goal.';
-/**
- * What a manager is told on every turn, on top of its own description in FlareDeck.
- *
- * It says what this harness gives a manager TODAY and, as plainly, what it does not yet stop:
- * the approval, heads-up and escalation steps of docs/spec-manager-role.md are not built, so the
- * limits below are instructions rather than guards. They come out as each guard goes in.
- */
-export const MANAGER_BRIEF = '\n\nYou are a MANAGER, not a worker. Nobody above you hands you cards or reviews them; you ' +
-    'answer to the person named in your description.\n' +
-    '  · `list-agents` shows your teams — the leads that report to you and their agents — what each ' +
-    'is working on, how long since it checked in, and the machine it runs on (disk, memory, load, ' +
-    'what is wrong there).\n' +
-    '  · `machine-exec` runs a command on one of those agents\' machines, as that agent\'s user: ' +
-    'read a log, see what is running, restore a missing file, stop servers a dead checkout left ' +
-    'behind. It runs under YOUR judgement, not the worker\'s guards, and every call is recorded.\n' +
-    'Your job is to unblock: do not build a worker\'s card for it. When an agent is stuck, find out ' +
-    'why and fix the cause, or tell its lead what you found.\n' +
-    'Your teams\' TECHNICAL, ACCESS and INFORMATION questions come to you before any person; ' +
-    'product, design and client questions go straight to the person the board names, and are not ' +
-    'yours. When one arrives, read the card and settle it if you can: look the answer up, fix the ' +
-    'machine, or answer from what the board already decided — then say so on the card and ' +
-    'clear-needs-human, so the agent carries on. If it turns out to need a person, pass it up: ' +
-    'set-needs-human on that card with the question, its options, your recommendation, and the kind ' +
-    'of question it really is. It goes to the person the board names for that kind.\n' +
-    'MERGING AND PROMOTING go through the `release` tool, and only through it. The board decides who may ' +
-    'release into each environment and who must agree first, and the tool enforces that and asks them ' +
-    'by itself — so do NOT ask a person for a merge or promote the board already lets you do, and do not ' +
-    'write merge scripts or keep a clone for them. If release refuses, its reason is the answer.\n' +
-    'NOT YET GUARDED HERE, so until it is, you do not do these without the person\'s say-so, asked ' +
-    'for with set-needs-human naming the exact action: deploying to production by any route other than ' +
-    'release; deleting directories, checkouts or data on a shared machine; changing board settings, ' +
-    'access or credentials; moving a card out of Backlog or a hidden lane.' +
-    '\n  · A place of your own that outlives any card: `~/.config/flaredeck-agent/scratch/`. Your ' +
-    'card\'s checkout is for that card; do not make clones anywhere else.';
-/** A manager's regular check is of its TEAMS, not of cards assigned to it. */
-export const MANAGER_SWEEP_BRIEF = '\n\nThis check is of your teams. Call `list-agents`. Look for: an agent with no word for a long ' +
-    'time, or stopped; one stuck on the same card with work queued behind it; a machine short of ' +
-    'disk or memory, or an agent running in a bare SSH session; a question to a person that has ' +
-    'waited long. Act on what you can fix yourself within the limits above. If everything is in ' +
-    'order, say so in one line and stop — do not message anyone to report that nothing happened.';
-/** For a lead handed a card in a folder with no code of its own. See leadWithoutCode. */
-export const LEAD_WITHOUT_CODE_BRIEF = '\n\nYou have no checkout of this card\'s code here, so you cannot build it yourself — and you ' +
-    'do not need to: you lead. Hand it to a worker who reports to you and is free, with assign-card ' +
-    'and a one-line note of what is wanted. If none is free, say so on the card and leave it assigned ' +
-    'to you; do not ask a person to set up a repository.';
-/** A "moved to X" event when the card now sits somewhere else. Unknown either way: not stale. */
-/**
- * Something written on a card by a harness, for the record — not by anyone, to anyone.
- *
- * A manager asking a person to approve a merge puts three things on the card within a minute: the
- * flag, the "Approval needed" comment, and later the "Production run … ran" output. Each reached
- * the card's builder as an event and cost it a turn to say "nothing for me to do until qa has it"
- * — HR-0801 woke HAL seven times that way in an afternoon. None of them asks the builder for
- * anything; whoever must act is told through the approval itself.
- *
- * Being NAMED still wakes an agent, whatever the comment is.
- */
-export function isBookkeeping(event, agents = new Set()) {
-    // "X needs your approval" is for a person: an agent cannot approve, and its lead is asked
-    // through a review, which is its own event. TARS was sent JARVIS's and spent a turn saying so.
-    // Before the check for being named: the event addresses whoever it reaches as "you", so it
-    // arrives marked as naming them, and the first version of this rule let every one through.
-    if (event.event === 'approval')
-        return true;
-    if (event.mentioned)
-        return false;
-    if (event.event === 'needs_human_set')
-        return true;
-    // A card's fields changing under a flag or a claim, by nobody in particular or by an agent.
-    // What a PERSON changes on a card is still news.
-    if (event.event === 'updated') {
-        const actor = (event.actor ?? '').trim().toLowerCase();
-        return !actor || actor === 'someone' || agents.has(actor);
-    }
-    if (event.event !== 'commented')
-        return false;
-    const said = `${event.message ?? ''}`.trim() || /— [^:]{1,60}: "(.*)$/s.exec(event.line ?? '')?.[1] || '';
-    return /^\**(Approval needed\b|Production run\b|No answer in \d+ minutes?, so\b)/.test(said.trim());
-}
-/**
- * One agent addressing ANOTHER on a card this agent holds: the comment opens with an @name, and
- * the name is not this agent's. "@Norm please merge this now" from the lead woke the card's
- * builder, which spent a turn establishing that it was not Norm (HR-0814, HR-0801). An agent that
- * wants the builder names the builder — and being named always wakes it.
- *
- * Only agents' comments. A person who writes "@Darren, thoughts?" on a card may well want the
- * builder to hear it, and people are not expected to know the rule.
- */
-export function forSomeoneElse(event, agents, me) {
-    if (event.event !== 'commented' || event.mentioned)
-        return false;
-    // Who said it and what, from the event's own fields or, where a producer leaves them out, from
-    // its line: `commented: HR-1 "title" — JARVIS: "@Norm please…`. The last such pair, since a
-    // card's title can hold a dash and a colon of its own.
-    const fromLine = [...(event.line ?? '').matchAll(/— ([^:"—]{1,60}): "/g)].pop();
-    const actor = ((event.actor ?? '').trim() || fromLine?.[1] || '').trim().toLowerCase();
-    if (!agents.has(actor))
-        return false;
-    const tail = fromLine ? (event.line ?? '').slice((fromLine.index ?? 0) + fromLine[0].length) : '';
-    // Markup around the first word must not hide it: "<p>@Norm" opens with a name too.
-    const said = (`${event.message ?? ''}`.trim() || tail).replace(/<[^>]+>/g, ' ').trim();
-    if (!/^@\S/.test(said))
-        return false;
-    // Its own name anywhere in it, whatever the event's flag says: without a name to check, stay awake.
-    const name = me.trim().toLowerCase();
-    return !!name && !said.toLowerCase().includes(`@${name}`);
-}
 /** See sessionDecider. Apart from the wiring, so it can be tested. */
 export async function decideForSession(request, options, via) {
     const command = request.toolName === 'Bash' ? String(request.input['command'] ?? '').trim() : '';
@@ -4791,227 +4371,6 @@ export async function decideForSession(request, options, via) {
     const v = await via.judge(command);
     return v.allow ? { allow: true } : { allow: false, reason: v.reason ?? 'Not allowed.' };
 }
-/**
- * Which Claude token a handover runs on: a fresh pick from FlareDeck, because the plan the turn
- * used may have run out since; the turn's own plan when FlareDeck cannot be asked; 'none' when
- * every plan is spent; null to fall back to this machine's own login (no subscriptions set up).
- */
-export async function handoverSubscription(subs, lastUsed) {
-    try {
-        const s = await subs();
-        if (!s)
-            return lastUsed ?? null;
-        const pick = await s.choose([]);
-        if (pick.use === 'token' && pick.token)
-            return pick.token;
-        if (pick.use === 'none')
-            return 'none';
-        return lastUsed ?? null;
-    }
-    catch {
-        return lastUsed ?? null;
-    }
-}
-export function moveIsStale(event, laneNow) {
-    if (event.event !== 'moved' || !event.laneName || !laneNow)
-        return false;
-    return event.laneName.trim().toLowerCase() !== laneNow.trim().toLowerCase();
-}
-/**
- * An event that waited behind other work says so. Norm (15 Oct): "by the time I act, the thing has
- * often already been done" — it re-checked everything before every action, not knowing which
- * events were fresh. Only past a few minutes; a fresh one needs no warning.
- */
-export function waitedNote(event, now = Date.now()) {
-    const m = event.receivedAt ? Math.round((now - event.receivedAt) / 60_000) : 0;
-    if (m < 3)
-        return '';
-    const age = m < 90 ? `${m} minutes` : `${Math.round(m / 60)} hours`;
-    return `(This arrived ${age} ago and waited behind other work. Check the card's lane and newest comments, and the branch, before acting: it may already be done.)\n\n`;
-}
-/** A card assigned to a lead in a lane where work has not started: the lead hands it out. */
-export function isLeadDispatch(event, isLead) {
-    if (!isLead || event.event !== 'assigned')
-        return false;
-    return !/doing|progress|review|test|deploy|await|release|waiting|done/i.test(String(event.laneName ?? ''));
-}
-export function prompt(event, isLead = false) {
-    /* A person giving the lead a card is giving it to the TEAM. JARVIS was assigned six cards at once
-       (19 Oct) and tried to start four itself, refused each time by the one-card rule. */
-    if (isLeadDispatch(event, isLead)) {
-        return [
-            `${event.line}`,
-            '',
-            'This card is on you to HAND OUT, not to do. Read it with get-card-details, then one of:',
-            '- It is clear and wanted: assign it to a free worker with assign-card (list-agents shows who is',
-            '  free and what each holds). Say on the card who has it and why, in one line.',
-            '- It needs a product or business decision first: ask with set-needs-human (short question,',
-            '  options), and leave it unassigned to a worker until it is answered.',
-            '- No worker is free: leave it where it is; workers take the next card themselves.',
-            '',
-            'Do not move it to Doing and do not start building it yourself.',
-        ].join('\n');
-    }
-    if (event.event === 'sweep') {
-        return [
-            'Nothing has arrived for a while, so this is a check of what you already hold. It is a',
-            'HANDOVER, not a working turn: you find the next piece of work and start it moving, and it',
-            'comes back to you properly a moment later.',
-            '',
-            'Call get-outstanding. It lists the cards assigned to you that are not done, and the comments',
-            'addressed to you that nobody has actioned.',
-            '',
-            ...(isLead
-                ? [
-                    'Then call get-portfolio, because get-outstanding only ever shows what is assigned to',
-                    'YOU. A card assigned to nobody is on no outstanding list anywhere — not yours, not any',
-                    'worker\'s — so it is invisible to the whole team for as long as it stays that way. Four',
-                    'bugs sat in a column unassigned while every agent reported itself idle.',
-                    '',
-                    'Anything actionable with no assignee is yours to place: give it to a worker with',
-                    'assign-card, newest bugs first. A worker can be given several cards that have not',
-                    'started: they queue, and it takes them one at a time. Spread them about evenly.',
-                    '',
-                    'Then look at the balance. list_agents shows what each one holds and how many are',
-                    'queued behind it. Where one worker has several cards waiting and another has none,',
-                    'move a card across with assign-card: a card queued behind a busy agent is not being',
-                    'worked, and the idle one could finish it today.',
-                    '',
-                    'Each agent is shown with the repository it has checked out. Move a card only to an',
-                    'agent that has the repository the card is for — on a board where everyone works the',
-                    'same one they are interchangeable, and on a board with a ui agent and an api agent',
-                    'they are not.',
-                    '',
-                ]
-                : []),
-            'If it returns nothing, say so in one line and stop. That is a perfectly good outcome and',
-            'costs nothing — do NOT go looking for work elsewhere, do not scan logs, and do not invent a',
-            'task to justify the turn.',
-            '',
-            'Otherwise take the FIRST one by priority and, depending on what it is:',
-            '',
-            '- A card for one of the agents who report to you: assign it to the right one. That dispatch',
-            '  IS the work, and this turn is done.',
-            '- A card that is yours and NOT already in progress: hand it to a worker if you have one free,',
-            '  with assign-card. You run one turn at a time, and a card takes minutes — for all of them you',
-            '  would be unable to assign anything or answer anyone, which is the one job only you can do.',
-            '  With nobody free, move it to the board\'s in-progress lane with update-card-status and stop:',
-            '  that hands it back to you as a card of its own, with a checkout and a branch, which is the',
-            '  only place work can be done and published from. Either way, stop here — reading it, starting',
-            '  it or commenting on it in this turn all edit the shared checkout, which publishes nowhere.',
-            '- A card already in progress: say which one in a line, and stop. The harness picks those up',
-            '  by itself, shortly, with a checkout of its own — you do not need to do anything for it.',
-            '',
-            'Then stop. One handover per check — the rest are still there next time.',
-        ].join('\n');
-    }
-    if (event.event === 'ask') {
-        return [
-            'The person watching this pane typed a question for you:',
-            '',
-            event.line,
-            '',
-            'Answer it here, in the pane, briefly and concretely — they are reading this terminal, not a',
-            'card. Use your FlareDeck tools to look things up: list-boards and get-board-info for the',
-            'board and its columns, get-cards-by-column for what sits in a column, get-card-details and',
-            'get-outstanding for who holds a card and whether anyone is on it, read-messages for a',
-            'thread. Look, then say what you found. Do NOT change anything — no comments, no moves, no',
-            'claims, no assignments, no needs-human — unless the question explicitly asks you to do it.',
-        ].join('\n');
-    }
-    if (event.event === 'scheduled') {
-        return [
-            `A scheduled task has come due: "${event.scheduleName || 'unnamed'}". A person approved this schedule,`,
-            'and FlareDeck is running it now. It is not a card — do what it says and report the result where it',
-            'says to (an email, a message, a comment). If it names nobody or nowhere to report, post a comment',
-            'on the most relevant card or send a direct message to the person who would care.',
-            '',
-            'The instruction:',
-            '',
-            event.prompt || event.message || event.line,
-            '',
-            'You have no memory of earlier runs, and nothing here may be undone by waiting: act, then finish.',
-            'Do not create further schedules from this run.',
-        ].join('\n');
-    }
-    // Card intake (docs/spec-card-intake.md): this agent is the board's reviewer of new cards.
-    if (event.event === 'intake') {
-        return [
-            'You are this board\'s intake reviewer. A card is waiting for you in the review lane:',
-            '',
-            event.line,
-            '',
-            'Read it with get-card-details. Your one question: could an agent work it as written? It needs',
-            'WHAT should change, WHERE (the screen, in the menu\'s words), and HOW YOU WOULD KNOW it is done;',
-            'for a bug, how to make it happen. Look in the code (find_code) before deciding something is',
-            'unclear — "the Goals page" may be obvious once you look.',
-            '',
-            'Then one review-card decision, and stop:',
-            '- Clear already: pass, with a one-line note.',
-            '- Clear enough to make clear: rewrite it first — set-card-description (keep the person\'s own',
-            '  words under a "Reported as" line), set-card-story with its "Done when", set-card-meta parts —',
-            '  then pass.',
-            '- Not clear: ask — ONE comment with every question in it, short, in plain words. At most two',
-            '  rounds; after that leave a one-line note of what is missing and stop. Do not chase.',
-            '- A worker\'s proposal (it says "Proposed by an agent"): pass it if it is real separate work,',
-            '  merge it into the card it belongs on, or decline it saying why.',
-            '',
-            'You review; you do not do the work, assign it, or start it. A card it was suggested to edit',
-            'shows the suggestion: apply it with set-card-description if it is right.',
-        ].join('\n');
-    }
-    if (event.event === 'review') {
-        return [
-            'A worker that reports to you is asking to run a script against production, and it cannot',
-            'go to a person until you have reviewed it:',
-            '',
-            event.line,
-            '',
-            'Read the card with get-card-details. The request is the newest comment carrying an approval,',
-            'with its comment id, the script, the worker\'s own account of it, and the harness\'s row-count',
-            'preview. Check that the WHERE clause matches the stated purpose and that the preview matches',
-            'the expected effect. Then call review_script with that comment id: endorse, and the',
-            'people who can approve it are asked; reject, and the worker is refused with your note. Do not',
-            'dispatch, re-assign, or change anything else — this is a review, not a card to work.',
-        ].join('\n');
-    }
-    // A card the HARNESS picked back up because it sits in progress with this agent's name on it.
-    // Finished work left there comes back on every check and blocks every other card.
-    const resumed = String(event.id ?? '').startsWith('resume-')
-        ? ['', 'You were handed this card again only because it is still in an in-progress lane assigned to',
-            'you. If its work is already finished — answered, delivered, nothing left for you — move it on to',
-            'its next lane with update-card-status NOW. Left in progress, it is handed back to you on every',
-            'check and FlareDeck will not let you start any other card. If it is waiting on a PERSON and you',
-            'may not move it yourself, call set-needs-human saying what they need to do — a card waiting on a',
-            'person is not handed back to you, and their answer wakes you.']
-        : [];
-    /* The event's one line quotes a message or comment only up to 200 characters, then says
-       "(truncated — read-messages for the full text)". The event itself carries the full text, and
-       the model was never given it: a person's longer instructions arrived cut ("his message reached
-       me cut off after 'for every c…'"), the fetch for the rest failed, and the agent acted on a
-       guess. When the line was cut, the full text goes in the prompt. */
-    const full = event.message && /\(truncated — /.test(event.line ?? '')
-        ? ['', 'The full text of that message:', '', ...String(event.message).split('\n').map((l) => `> ${l}`)]
-        : [];
-    return [
-        `A FlareDeck event just arrived for you:`,
-        '',
-        event.line,
-        ...full,
-        ...resumed,
-        '',
-        'Deal with it. Read the card before you change anything — INCLUDING its agent notes, where a',
-        'previous session may have left a handover: what it got to, what it tried that failed,',
-        'what about this environment cost it time. Those notes are the CARD\'s, and the last agent',
-        'to work it wrote them — the card says who. If that was not you, the "I" in them is that',
-        'agent: use them to know where the card stands, never as your own history, and never as',
-        'your own comments or your own lessons. Keep your todo list in step with the',
-        'work, and comment on the card so a person can follow what you did. If you cannot finish —',
-        'you need a decision, an approval, or something is blocking you — call set-needs-human and say',
-        'what you need. Nobody is watching this terminal, so stopping without saying so is the one',
-        'thing that does not work.',
-    ].join('\n');
-}
 /** An MCP tool result that says the server refused the session's credentials. */
 export function mcpSignInRejected(tool, response) {
     if (!tool.startsWith('mcp__') || tool.startsWith('mcp__flaredeck__'))