@onepointfour-packs/flaredeck-agent 0.2.215 → 0.2.217

package/dist/serve.js

@@ -11,7 +11,7 @@ import { answerFrom, createPresence, heldFor, modeCommand } from './presence.js'
 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 { boardsNaming, fetchLadder, isSoloWorker, namedOnLadders, releasePermissionAsk, releaseRightsBrief, releaseRightsForJudge, releaseTools } from './release.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';
@@ -22,6 +22,7 @@ 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';
+import { NO_TIMESHEETS, TimesheetLedger, timesheetRule } from './timesheets.js';
 import { SCRIPT_REQUEST, allTargets, rerouteTo, resumeApprovedRuns, runTools } from './runs.js';
 import { deliverDecision, flaredeckDecider } from './approval.js';
 import { subscriptionsForAgent } from './subscriptions.js';
@@ -717,13 +718,36 @@ 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`);
     };
+    /** When the turn now running began: anything a person said after that, the agent has not read. */
+    let turnSince = 0;
     const park = (cardKey, why) => {
         if (!cardKey)
             return;
-        parked.set(cardKey, { why, since: Date.now() });
+        /* From the start of the turn that parks it, not the moment it parks. HRG-0012 (30 Oct): Cobus
+           answered "Yes, release to prod" while FRIDAY's turn was still flagging the card; the answer
+           arrived four seconds before the park, counted as "before the question", and the card sat
+           until somebody else replied. What arrived before the turn began is still excluded (HR-0932). */
+        const since = turnSince && Date.now() - turnSince < 2 * 60 * 60_000 ? turnSince : Date.now();
+        parked.set(cardKey, { why, since });
     };
     /** What the agent can reach for the card in hand, for the guard's judge. Set per card. */
     let reachable = null;
+    /** The ladder of the board this turn's card is on — the release settings Jev and the agent are told. */
+    let boardLadder = null;
+    const ladderCache = new Map();
+    const ladderFor = async (boardId) => {
+        if (!boardId)
+            return null;
+        const hit = ladderCache.get(boardId);
+        if (hit && Date.now() - hit.at < 5 * 60_000)
+            return hit.ladder;
+        const tid = tenantFromToken(await opts.auth());
+        const ladder = tid ? await fetchLadder(config.mcpUrl, tid, boardId, () => opts.auth()).catch(() => null) : null;
+        ladderCache.set(boardId, { at: Date.now(), ladder });
+        return ladder;
+    };
+    /** The role the release tool checks against — said the same way to the agent and to Jev. */
+    const myReleaseRole = () => releaseRole(profile, soloWorker);
     /**
      * The pane's list of script requests waiting on a person: this agent's own request and, on a
      * lead's pane, its team's. Read from the server — the one place every request and verdict
@@ -856,6 +880,9 @@ export async function serve(opts) {
                         : '')
                 : 'no running services and no database of its own — nothing is started for this card');
             out.push('it CANNOT push to any git branch: publishing goes through a reviewed path it does not control');
+            const rights = releaseRightsForJudge(boardLadder, myReleaseRole(), selfId ?? '');
+            if (rights)
+                out.push(rights);
             const targets = Object.keys(config.runs ?? {});
             out.push(targets.length
                 ? `production systems the harness can run an APPROVED script against: ${targets.join(', ')} — only after a person approves that exact script, never by a command the agent runs itself`
@@ -879,6 +906,7 @@ 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),
+            releaseAsk: (text) => releasePermissionAsk(text, boardLadder, myReleaseRole(), selfId ?? ''),
             sendFile: (path, to, message) => sendFile(onCard?.cwd ?? config.repo, path, to || chat.person()?.uid || '', message),
             flag: async (reason, kind, ask, flagOpts) => {
                 const cur = onCard;
@@ -1053,7 +1081,10 @@ 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(profile.tools, name);
+    /** The workspace's timesheet rule (Integrations → Agent timesheets), and what has been logged. */
+    let timesheets = NO_TIMESHEETS;
+    const timesheetLedger = new TimesheetLedger();
+    const keepTool = (name) => offeredTo(profile.tools, name, timesheets.required);
     /** Cards handed to the lead for review, and the branch head then. See features/hand-back.ts. */
     const handedBack = handBackMemory();
     try {
@@ -1087,6 +1118,9 @@ export async function serve(opts) {
         if (leadId)
             log('tool', `your lead is ${leadName} — ${leadName} verifies your work before it goes anywhere`);
         profile = profileFor(team.you.role);
+        timesheets = timesheetRule(team.you.timesheets);
+        if (timesheets.required)
+            log('tool', 'this workspace bills agents\' time — every card you finish gets a timesheet entry');
         if (profile.chat) {
             state.waitingFor = undefined;
             await chat.start(tenantFromToken(await opts.auth()));
@@ -2851,6 +2885,7 @@ export async function serve(opts) {
             if (beside.length && !event.alongside?.length)
                 event = { ...event, alongside: beside };
         }
+        turnSince = Date.now();
         let repoChoiceNote = '';
         // An assistant's card on a board it releases for: the board says which repository. A card the
         // harness picked up itself carries none, and with one checkout here the turn took that one —
@@ -3785,6 +3820,7 @@ export async function serve(opts) {
             lead: leadId ? { id: leadId, name: leadName } : null,
             selfId,
             handedBack,
+            timesheet: () => timesheetLedger.gate(tag || event.cardCode || event.cardKey || '', timesheets, event.cardKey || ''),
             handToLead: async (code, message) => {
                 const token = await opts.auth();
                 await callFlaredeckTool(config.mcpUrl, token, 'assign-card', { card_id: code, assignee: leadId });
@@ -3810,7 +3846,7 @@ export async function serve(opts) {
             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 flaredeck = flaredeckProxy(config.mcpServerName, config.mcpUrl, opts.auth, check.discovered, (w) => log('warn', w), gate, noteCard, keepTool, savedSoFar, [...myBoards], (name, args) => timesheetLedger.record(name, args));
         const card = await prepareCard(event, key, repo, queuedBehind);
         if (!card)
             return;
@@ -3828,6 +3864,7 @@ export async function serve(opts) {
          * named. FlareDeck takes a human code wherever it takes a card id, so the code alone is
          * enough to flag, comment and clear.
          */
+        boardLadder = await ladderFor(event.boardKey);
         onCard = event.cardKey
             ? {
                 card: event.cardKey,
@@ -3925,6 +3962,7 @@ export async function serve(opts) {
             standing: standingBrief(!!teamSet, config.style ?? process.env['FLAREDECK_AGENT_STYLE'], isAssistantChat, config.mcpServers, config.trustedScripts),
             finish: gate,
             noteCard,
+            called: (name, args) => timesheetLedger.record(name, args),
             keep: keepTool,
             saved: savedSoFar,
             token: await opts.auth(),
@@ -3983,6 +4021,7 @@ export async function serve(opts) {
         const brief = waitedNote(event) + prompt(event, profile.dispatch) + thread + intakeText(prepared) +
             workspaceBrief(config.repo, await checkouts(config.repo, scope), chosen) +
             worktreeBrief(tree) + (tree ? folderBrief(tree) : '') + notes + repoChoiceNote + (await resumeBrief(event.cardCode || event.cardKey || '', tree)) +
+            releaseRightsBrief(boardLadder, myReleaseRole(), selfId ?? '') +
             unclearBrief(prepared?.jev ?? null, leadName) + preflightBrief(checks) + backBrief(event) +
             // 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 }) +