@onepointfour-packs/flaredeck-agent 0.2.171 → 0.2.173

package/dist/serve.js

@@ -40,9 +40,11 @@ import { updateSidecarSdk } from './updater-python.js';
 import { managedPython, usingManagedPython } from './engine-antigravity.js';
 import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { configDir, loadGitHub, saveConfig, slug } from './config.js';
+import { configDir, loadConfig, loadGitHub, saveConfig, slug } from './config.js';
 import { boardArg, onMyBoards, outstandingCards } from './boards.js';
 import { browserTools, ensureBrowser } from './browser.js';
+import { AGY_HELPERS_BRIEF, HELPERS_BRIEF, helperTools } from './helpers.js';
+import { jamEvidence as jamEvidenceFor, loadJam as loadJamTokens } from './jam.js';
 import { environmentTools } from './envtools.js';
 import { watchForDesperation } from './desperation.js';
 import { note, recallWorktree, rememberWorktree, resumeBrief } from './journal.js';
@@ -3428,6 +3430,22 @@ export async function serve(opts) {
          * the card waits for the reset, as it would for a spent plan.
          */
         let turnEngine = engine;
+        /* Helpers (helpers.ts): on for this agent while they are measured. 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 on the card, so it is never lost and never polled for. */
+        // Read from the file each turn, so turning helpers on or off needs no restart.
+        const helpersOn = !isAssistant && ((loadConfig(config.repo)?.helpers ?? config.helpers) === true || process.env['FLAREDECK_AGENT_HELPERS'] === '1');
+        let thisRun = null;
+        const deliverHelper = async (text) => {
+            if (thisRun && liveRun === thisRun && await thisRun.steer(text).catch(() => false))
+                return;
+            if (!event.cardKey) {
+                log('warn', `a helper finished after the turn ended, with no card to bring it back to: ${text.split('\n')[0]}`);
+                return;
+            }
+            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) {
@@ -3458,6 +3476,29 @@ export async function serve(opts) {
                 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,
+                ...(web ? { defaultPart: () => web } : {}),
+                sites: () => declaredSites,
+                contract: () => env.contract,
+                cwd,
+                onNote: (t) => log('tool', t),
+            }),
+            jam: async (url) => {
+                const tokens = loadJamTokens();
+                if (!tokens)
+                    return null;
+                const e = await jamEvidenceFor(url, tokens, (t) => log('tool', t));
+                return e.ok ? e.text : null;
+            },
+            deliver: deliverHelper,
+            log: (t) => log('tool', t),
+        }) : null;
         const engineContext = {
             ...(leadGoal ? { goal: leadGoal } : {}),
             config: { ...config, repo: cwd, ...(isAssistant ? { assistantMode: true } : {}) },
@@ -3495,7 +3536,9 @@ export async function serve(opts) {
             ...(prepared?.model ? { model: prepared.model } : {}),
             ...(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 } } : {}),
                 // The project's file storage, when a person has set one up for these boards.
                 ...(await turnFileTools(cwd, forACard, event.environment) ?? {}),
@@ -3545,8 +3588,9 @@ export async function serve(opts) {
                     `the card, tell whoever owns the board that ${START_SCRIPT_NAME} does not survive parallel ` +
                     `worktrees — it must take a free port AND pass that port to the parts that call it — and stop.`
                 : '');
-        const run = turnEngine.run(brief, engineContext);
+        const run = turnEngine.run(brief + (helpersOn ? (turnEngine.name === 'antigravity' ? AGY_HELPERS_BRIEF : HELPERS_BRIEF) : ''), engineContext);
         liveRun = run;
+        thisRun = run;
         if (isAssistant)
             liveFeed?.start(String(event.message ?? event.line ?? '').split('\n').filter(Boolean).pop() ?? '');
         // Connected MCP servers' tokens, kept current for as long as the session runs. FlareDeck hands