@onepointfour-packs/flaredeck-agent 0.2.112 → 0.2.113

package/dist/serve.js

@@ -8,6 +8,7 @@ import { freshGitHubToken } from './githubauth.js';
 import { answerFrom, createPresence, heldFor, modeCommand } from './presence.js';
 import { defaultUploadRoots, fileTools, flaredeckStores } from './filestore.js';
 import { scratchFor } from './cardmess.js';
+import { ASSISTANT_KEY, latestCliSession, assistantBrief, assistantIgnores, assistantPerson, asAssistantEvent, loadAssistantSession, saveAssistantSession } from './assistant.js';
 import { codePrefix, loadPrefixes, savePrefixes, SCRATCH_SWEEP_EVERY_MS, sweepScratch } from './scratch.js';
 import { findImages, namedForAgent } from './images.js';
 import { loadBaseBranch, loadMergeConfig, preflight, preflightBrief } from './preflight.js';
@@ -858,6 +859,13 @@ export async function serve(opts) {
     let isLead = false;
     /** A manager: above the leads, with no lead of its own. See MANAGER_BRIEF. */
     let isManager = false;
+    /**
+     * 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;
+    const assistantSessionFile = join(configDir(), 'assistant-sessions', `${slug(`${opts.agent ?? 'agent'}-${config.repo}`)}.json`);
     /** The mode and the held questions, as the pane draws them. */
     const showPresence = () => {
         if (!isManager) {
@@ -869,7 +877,7 @@ 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 ? 'manager' : isLead ? 'lead' : 'worker', name);
+    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();
     try {
@@ -898,6 +906,15 @@ export async function serve(opts) {
         // 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) {
+            const tenant = tenantFromToken(await opts.auth());
+            person = tenant ? await assistantPerson(config.mcpUrl, tenant, () => opts.auth()) : null;
+            const kept = loadAssistantSession(assistantSessionFile);
+            log('event', person
+                ? `You are ${person.name}'s assistant — you listen only to them, in FlareDeck chat${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.');
+        }
         showPresence();
         if (isManager) {
             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.');
@@ -1452,6 +1469,8 @@ export async function serve(opts) {
             files: fileTools(stores, source, () => onCard ? { card: onCard.card, ...(onCard.code ? { code: onCard.code } : {}), ...(envKey ? { environment: envKey } : {}) } : null, () => defaultUploadRoots(cwd, forACard ? scratchFor(cwd) : undefined), (t) => log('tool', t)),
         };
     };
+    /** The subscription each open session last ran on — a fallback for its handover. */
+    const planOfSession = new Map();
     /** One session per card, so an agent picking a card back up remembers starting it. */
     const sessions = new Map();
     /**
@@ -1696,7 +1715,7 @@ export async function serve(opts) {
             await enterPause(wall);
     })();
     const sweepNow = () => {
-        if (paused || !sweepsEnabled || stopping)
+        if (paused || !sweepsEnabled || stopping || isAssistant)
             return;
         // Busy is reason enough to wait: the next tick is minutes away and the work is not going
         // anywhere.
@@ -1738,6 +1757,8 @@ export async function serve(opts) {
     const resumedIdle = new Map();
     const RESUME_IDLE_LIMIT = 2;
     const resumeOwnWork = async () => {
+        if (isAssistant)
+            return false; // an assistant has no "own work" — only its person's asks
         /* 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)
@@ -2332,11 +2353,26 @@ export async function serve(opts) {
             log('event', `${event.cardCode || event.cardKey}: ${event.actor} is talking to somebody else on the card — nothing to do`);
             return;
         }
+        // An assistant hears its person and nothing else, and works outside the card machinery.
+        if (isAssistant) {
+            const why = assistantIgnores(event, person?.uid ?? null);
+            if (why) {
+                log('event', `${event.cardCode || event.event}: ${why} — not for ${person?.name ?? 'anyone'}'s assistant`);
+                return;
+            }
+            event = asAssistantEvent(event, person?.name ?? 'your person');
+            // The conversation from before a restart, picked up where it was.
+            if (!sessions.has(ASSISTANT_KEY)) {
+                const kept = loadAssistantSession(assistantSessionFile);
+                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;
         }
-        let key = event.cardKey || (event.event === 'ask' ? 'ask' : event.event === 'sweep' ? 'sweep' : event.event === 'scheduled' ? `schedule-${event.scheduleId}` : 'inbox');
+        let key = isAssistant ? 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.
@@ -2461,7 +2497,15 @@ export async function serve(opts) {
          */
         if (event.event === 'ask' && tree)
             key = `ask:${tree.path}`;
-        const cwd = tree?.path ?? repo;
+        // An assistant's very first turn, with no conversation of its own: its person's newest Claude
+        // CLI session in this folder, carried on as a FORK — the history comes across, the person's
+        // own session file is left as it was, and the two never write to the same place.
+        const pickedUp = isAssistant && key === ASSISTANT_KEY && !sessions.get(key) ? latestCliSession(config.repo) : null;
+        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)`);
+        // An assistant always works from the folder it was started in: that is where its person's own
+        // Claude sessions live, and where `continue` finds the one to carry on.
+        const cwd = isAssistant ? config.repo : tree?.path ?? repo;
         // Back on this checkout: whatever was waiting to take its environment down can stand down.
         turnCwd = cwd;
         const pendingStop = idleStops.get(cwd);
@@ -2982,6 +3026,7 @@ export async function serve(opts) {
             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);
         }
         if (claudePlan?.use === 'none') {
             const when = claudePlan.availableAt ? new Date(claudePlan.availableAt).toLocaleString() : 'later';
@@ -3018,7 +3063,7 @@ export async function serve(opts) {
         }
         const engineContext = {
             ...(leadGoal ? { goal: leadGoal } : {}),
-            config: { ...config, repo: cwd },
+            config: { ...config, repo: cwd, ...(isAssistant ? { assistantMode: 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.
             //
@@ -3033,7 +3078,8 @@ export async function serve(opts) {
             // did exactly that, in the shared checkout every worktree is cut from, on a branch of its
             // own. Without a worktree there is nowhere legitimate to write, so the turn gets scratch
             // space and has to hand the card back instead.
-            sandbox: tree ? tree.path : scratchDir(),
+            // An assistant is not confined to a checkout: it works for one person, anywhere they need.
+            ...(isAssistant ? {} : { sandbox: tree ? tree.path : scratchDir() }),
             decider: sessionDecider,
             // Both only reachable in-process, so an out-of-process engine is handed them explicitly
             // rather than being left unable to publish and unchecked when it says it has.
@@ -3045,6 +3091,9 @@ export async function serve(opts) {
             saved: savedSoFar,
             token: await opts.auth(),
             ...(resume ? { resume } : {}),
+            // An assistant with no conversation of its own yet carries on its person's last Claude
+            // session in this folder — the one they were working in before the assistant existed.
+            ...(!resume && isAssistant && key === ASSISTANT_KEY && pickedUp ? { resume: pickedUp, forkSession: true } : {}),
             ...(prepared?.model ? { model: prepared.model } : {}),
             ...(prepared?.size ? { size: prepared.size } : {}),
             ...(claudePlan?.use === 'token' ? { claudeToken: claudePlan.token } : {}),
@@ -3083,6 +3132,7 @@ export async function serve(opts) {
             unclearBrief(prepared?.jev ?? null, leadName) + preflightBrief(checks) + backBrief(event) +
             freeWorkerBrief(event) + (leadWithoutCode ? LEAD_WITHOUT_CODE_BRIEF : '') +
             (isManager ? MANAGER_BRIEF + (event.event === 'sweep' ? MANAGER_SWEEP_BRIEF : '') : '') +
+            (isAssistant ? assistantBrief(person) : '') +
             // Only tell an agent about the environment when the card actually needs one running.
             environmentBrief(env, cwd, needsRunning) + notStartedBrief(forACard && !needsRunning, cwd) +
             browserBrief(env.endpoints, declaredSites, forACard, web) +
@@ -3189,8 +3239,11 @@ export async function serve(opts) {
                     void report();
                 }
                 else if (out.kind === 'ready') {
-                    if (out.sessionId)
+                    if (out.sessionId) {
                         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
@@ -3262,6 +3315,10 @@ export async function serve(opts) {
         failedPlans.delete(event.id);
         if (runError)
             throw runError;
+        // An assistant's conversation is never handed over or closed: it is one long talk with one
+        // person, compacted by the SDK as it grows, and resumed after a restart from the saved id.
+        if (isAssistant)
+            return;
         // A question from the pane: no card to hand over to. Its session is kept so the next question
         // can build on this one, and simply dropped once it has grown too large to be worth carrying.
         if (event.event === 'ask') {
@@ -3370,6 +3427,17 @@ export async function serve(opts) {
            so the shared checkout serves. */
         if (!existsSync(cwd))
             cwd = config.repo;
+        // The handover runs on a subscription FlareDeck picks, like any turn. It ran on this
+        // machine's own Claude login instead, and when that account had used its week every handover
+        // failed — "You've hit your weekly limit" — while the turns before it ran fine on the plan
+        // they were given (Norm at 14:00, an HR Goat agent at 14:34, 14 Oct). With every plan spent
+        // there is nothing to run it on; the card keeps its last note.
+        const handoverPlan = await handoverSubscription(() => subscriptionsForAgent(config.mcpUrl, () => opts.auth(), (t) => log('tool', t)), planOfSession.get(key));
+        if (handoverPlan === 'none') {
+            log('warn', `${key}: every Claude subscription is used up — no handover note this time`);
+            sessions.delete(key);
+            return;
+        }
         try {
             const wrapUp = engine.run((done
                 ? [
@@ -3407,6 +3475,7 @@ export async function serve(opts) {
                 decider: sessionDecider,
                 token: await opts.auth(),
                 ...(resume ? { resume } : {}),
+                ...(handoverPlan ? { claudeToken: handoverPlan } : {}),
                 tools: { team: teamSet, flaredeck: await proxyForWrapUp() },
             });
             liveRun = wrapUp;
@@ -3699,6 +3768,27 @@ 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;