@cluesmith/codev 3.3.4 → 3.3.6

package/dist/agent-farm/servers/tower-routes.js

@@ -21,24 +21,27 @@ import { decodeWorkspacePath } from '../lib/tower-client.js';
 import { readCloudConfig } from '../lib/cloud-config.js';
 import { fileURLToPath } from 'node:url';
 import { version } from '../../version.js';
-import { sanitizeAgentEnv } from '../../lib/agent-env.js';
+import { sanitizeAgentEnv, withTowerPort } from '../../lib/agent-env.js';
 const execAsync = promisify(exec);
-import { getBuilders, setArchitectByName } from '../state.js';
+import { getArchitectByName, getBuilders, setArchitectByName } from '../state.js';
+import { DEFAULT_ARCHITECT_NAME } from '../utils/architect-name.js';
 import { DEFAULT_COLS, defaultSessionOptions } from '../../terminal/index.js';
 import { parseJsonBody, isRequestAllowed, isAllowedOrigin, isAllowedHost, getExpectedKey, escapeHtml } from '../utils/server-utils.js';
-import { TOWER_KEY_HEADER, LEGACY_WEB_KEY_HEADER, VSCODE_USER_SENDER } from '@cluesmith/codev-types';
+import { TOWER_KEY_HEADER, LEGACY_WEB_KEY_HEADER, VSCODE_USER_SENDER, DECISIONS_TAB_SENDER } from '@cluesmith/codev-types';
 import { isRateLimited, normalizeWorkspacePath, getLanguageForExt, getMimeTypeForFile, serveStaticFile, persistableCommand, logSessionIdentity, } from './tower-utils.js';
 import { handleTunnelEndpoint } from './tower-tunnel.js';
 import { handleIdeApi } from './ide-server.js';
 import { matchIdePrefix, forwardIdeHttp } from './ide-forward.js';
 import { getWorktreeConfig, getActivityHooks } from '../utils/config.js';
 import { ensureCodevConfigWatcher } from './codev-config-watcher.js';
+import { handleDecisionsGet, handleDecisionsRule } from './decisions/routes.js';
+import { decisionsFilePresent } from './decisions/file.js';
 import { hasTeam, loadTeamMembers, loadMessages } from '../../lib/team.js';
 import { fetchTeamGitHubData } from '../../lib/team-github.js';
 import { resolveTarget, resolveAgentInRegistry, broadcastMessage, isResolveError } from './tower-messages.js';
 import { handleCommandRoute, COMMAND_ROUTE } from './command-relay.js';
 import { handleCanvasRoute, CANVAS_ROUTE_PREFIX } from './canvas-relay.js';
-import { formatArchitectMessage, formatArchitectToBuilderMessage, formatBuilderMessage, formatUserViaVsCodeMessage, isSafeSenderId, messageTooLargeError, MAX_MESSAGE_BYTES, } from '../utils/message-format.js';
+import { formatArchitectMessage, formatArchitectToBuilderMessage, formatBuilderMessage, formatUserViaVsCodeMessage, formatUserViaDecisionsTabMessage, isSafeSenderId, messageLimitError, messageTooLargeError, MAX_MESSAGE_BYTES, } from '../utils/message-format.js';
 import { writeMessageToSession, writeEscapeToSession, writeStrategyForApp } from './message-write.js';
 import { makeDeliveryPorts, getMailboxDrainer, resolveProfileForSession } from './mailbox-wiring.js';
 import { deliverAgentMailSerialized } from './mailbox-delivery.js';
@@ -56,8 +59,12 @@ import { submitToSession, OPERATOR_SUBMIT_WAIT_CEILING_MS } from './session-subm
 // triggers a gated drain (see handleSend), so a delayed message delivers onto a
 // render-verified empty prompt like any normal send — never force-injected.
 import { scheduleDelayedSend, validateDelaySeconds } from './delayed-send.js';
-import { getKnownWorkspacePaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, instancesReady, stopInstance, addArchitect, removeArchitect, } from './tower-instances.js';
+import { getKnownWorkspacePaths, getAllKnownWorkspacePaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, instancesReady, stopInstance, addArchitect, removeArchitect, } from './tower-instances.js';
 import { OverviewCache } from './overview.js';
+import { handleAgentLifecycle } from './agent-state/route.js';
+import { agentStateStore } from './agent-state/store.js';
+import { resolveAgentIdentity } from './agent-state/identity.js';
+import { serveAgentState } from './agent-state/serve.js';
 import { fetchIssue, fetchPR, searchIssues, fetchPRList, fetchCurrentUser, probeGhGraphqlRateLimit, parseLinkedIssue, parseArea, } from '../../lib/github.js';
 import { computeAnalytics } from './analytics.js';
 import { getAllTasks, executeTask, getTaskId } from './tower-cron.js';
@@ -90,6 +97,11 @@ const ROUTES = {
     'POST /api/overview/refresh': (_req, res, _url, ctx) => handleOverviewRefresh(res, ctx),
     'GET /api/events': (req, res, _url, ctx) => handleSSEEvents(req, res, ctx),
     'POST /api/notify': (req, res, _url, ctx) => handleNotify(req, res, ctx),
+    // Spec 1595: write-only lifecycle ingestion; key-authenticated like every non-public route.
+    'POST /api/agent-lifecycle': (req, res) => handleAgentLifecycle(req, res, {
+        store: agentStateStore,
+        resolve: identity => resolveAgentIdentity(identity),
+    }),
     'GET /api/browse': (_req, res, url) => handleBrowse(res, url),
     'POST /api/create': (req, res, _url, ctx) => handleCreateWorkspace(req, res, ctx),
     'POST /api/launch': (req, res) => handleLaunchInstance(req, res),
@@ -240,6 +252,10 @@ export async function handleRequest(req, res, ctx) {
     }
     catch (err) {
         ctx.log('ERROR', `Request error: ${err.message}`);
+        // A handler may fail after it has answered (the Decisions route keeps working past its
+        // `res.end()`); a second writeHead would throw ERR_HTTP_HEADERS_SENT out of here.
+        if (res.headersSent)
+            return;
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: err.message }));
     }
@@ -576,7 +592,9 @@ async function handleWorkspaceAction(req, res, ctx, match) {
     }
     // POST /api/workspaces/:path/deactivate
     if (req.method === 'POST' && action === 'deactivate') {
-        const knownPaths = getKnownWorkspacePaths();
+        // Unfiltered on purpose (#1809): a stray architect left running in a builder
+        // worktree is excluded from the listing but must still be stoppable.
+        const knownPaths = getAllKnownWorkspacePaths();
         const resolvedPath = fs.existsSync(workspacePath) ? fs.realpathSync(workspacePath) : workspacePath;
         const isKnown = knownPaths.some((p) => p === workspacePath || p === resolvedPath);
         if (!isKnown) {
@@ -629,8 +647,9 @@ async function handleTerminalCreate(req, res, ctx) {
                 // Strip Claude Code session markers so spawned Claude processes don't
                 // detect nesting and disable transcript saving (#1219). `env` is normally
                 // absent — `createPtySession` sends no env — so this is the path by which
-                // Tower's own environment becomes every builder's environment.
-                const sessionEnv = sanitizeAgentEnv(env || process.env);
+                // Tower's own environment becomes every builder's environment. Spec 1595:
+                // Tower's port is set last, so an inherited value never survives.
+                const sessionEnv = withTowerPort(sanitizeAgentEnv(env || process.env), ctx.port);
                 const client = await shellperManager.createSession({
                     sessionId,
                     command,
@@ -685,7 +704,10 @@ async function handleTerminalCreate(req, res, ctx) {
         // Fallback: non-persistent session (graceful degradation per plan)
         // Shellper is the only persistence backend for new sessions.
         if (!info) {
-            info = await manager.createSession({ command, args, cols, rows, cwd, env: env && sanitizeAgentEnv(env), label });
+            // Spec 1595: the manager merges this over its own base env, so Tower's port
+            // reaches the session whether or not the client supplied an env.
+            const sessionEnv = withTowerPort(sanitizeAgentEnv(env ?? {}), ctx.port);
+            info = await manager.createSession({ command, args, cols, rows, cwd, env: sessionEnv, label });
             persistent = false;
             if (workspacePath && termType && roleId) {
                 const entry = getWorkspaceTerminalsEntry(normalizeWorkspacePath(workspacePath));
@@ -916,19 +938,29 @@ async function handleStatus(res) {
  * dashboard-state handler (`/api/state`) and the overview handler
  * (`/api/overview`), so the two payloads list an identical set and can't drift.
  * Extracted verbatim from the dashboard-state builder's former inline loop.
+ *
+ * Spec 1595: each architect also carries its served `agentState` (read by
+ * `(workspace, name)` from the agent-state store and liveness, projected per
+ * request) and its session's `lastDataAt`, for the sdk's staleness rule.
  */
-function liveArchitects(entry, manager) {
+function liveArchitects(entry, manager, workspacePath) {
+    const agentWorkspace = normalizeWorkspacePath(workspacePath);
     const architects = [];
     for (const [architectName, terminalId] of entry.architects) {
         const session = manager.getSession(terminalId);
         if (!session)
             continue;
+        let lastDataAt = null;
+        if (Number.isFinite(session.lastDataAt))
+            lastDataAt = new Date(session.lastDataAt).toISOString();
         architects.push({
             name: architectName,
             port: 0,
             pid: session.pid || 0,
             terminalId,
             persistent: isSessionPersistent(terminalId, session),
+            agentState: serveAgentState(agentWorkspace, architectName, { blocked: false, blockedSince: null, phase: '' }),
+            lastDataAt,
         });
     }
     const mainIdx = architects.findIndex(a => a.name === 'main');
@@ -987,11 +1019,27 @@ async function handleOverview(res, url, workspaceOverride, ctx) {
         }
         builder.lastDataAt = new Date(ptySession.lastDataAt).toISOString();
     }
+    // Spec 1595: project the served agent state over EVERY listed builder, not
+    // inside the loop above, which skips a builder whose session is gone (the
+    // case liveness reports as dead). Every listed builder is registered: the
+    // list is filtered to `entry.builders`, and its `roleId` is the lowercased
+    // registry key, the same key the store and liveness use. `blocked` reuses the
+    // gate the overview already detected (no second parse of status.yaml).
+    const agentWorkspace = normalizeWorkspacePath(workspaceRoot);
+    for (const builder of data.builders) {
+        if (builder.roleId === null)
+            continue;
+        builder.agentState = serveAgentState(agentWorkspace, builder.roleId, {
+            blocked: builder.blocked !== null,
+            blockedSince: builder.blockedSince,
+            phase: builder.phase,
+        });
+    }
     // Issue 1104: enrich with the live architects (main-first) so the VSCode
     // Agents tree can render its architect tier and attribution badge straight
     // off the overview cache. Same `liveArchitects` helper (and so the same set)
     // the dashboard-state handler uses.
-    data.architects = liveArchitects(entry, terminalManager);
+    data.architects = liveArchitects(entry, terminalManager, workspaceRoot);
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
 }
@@ -1332,6 +1380,9 @@ function formatMessageForTarget(isArchitectTarget, from, toAgent, message, raw)
     // header, so the architect can tell it from a peer-architect instruction.
     if (isArchitectTarget && from === VSCODE_USER_SENDER)
         return formatUserViaVsCodeMessage(toAgent, message, undefined, raw);
+    // #1828: likewise the owner's ruling relayed by the Decisions tab — never a builder frame.
+    if (isArchitectTarget && from === DECISIONS_TAB_SENDER)
+        return formatUserViaDecisionsTabMessage(toAgent, message, raw);
     if (isArchitectTarget && from)
         return formatBuilderMessage(from, toAgent, message, undefined, raw); // builder → architect
     // any → builder: thread the sender so an `architect:<name>` origin is named in the
@@ -1397,6 +1448,45 @@ export async function deliverCronMessage(task, message, log) {
     log('WARN', `Cron '${task.name}': target '${task.target}' not found — message not delivered`);
     return { outcome: 'unresolved', reason: null, detail: null, mailboxId: null };
 }
+/**
+ * Tell a workspace's hub architect about a ruling the owner just wrote from the
+ * Decisions tab (#1828). The hub is the architect registered as `main` and no other:
+ * the registry's "first registered" order is by name (#1633), so a workspace without
+ * `main` gets no notice rather than a guess, and a `main` that is offline holds it
+ * (`no-live-pty`). One mailbox row is persisted, then offered to the same gated delivery
+ * `handleSend` uses; a busy line holds it for the backstop. Throws, persisting nothing,
+ * when `main` is not registered or the notice is over the send limit.
+ */
+async function notifyHubOfRuling(workspacePath, message, log) {
+    const tooLarge = messageLimitError(message);
+    if (tooLarge)
+        throw new Error(tooLarge);
+    const toAgent = DEFAULT_ARCHITECT_NAME;
+    if (!getArchitectByName(workspacePath, toAgent)) {
+        throw new Error(`no architect named '${toAgent}' is registered in workspace ${workspacePath}`);
+    }
+    const db = getGlobalDb();
+    const row = enqueueMailbox(db, {
+        workspacePath,
+        toAgent,
+        body: message,
+        formattedMessage: formatMessageForTarget(true, DECISIONS_TAB_SENDER, toAgent, message, false),
+        fromAgent: DECISIONS_TAB_SENDER,
+        fromWorkspace: workspacePath,
+    });
+    const ports = makeDeliveryPorts(log);
+    ports.onHeldStateChange();
+    try {
+        const outcome = await deliverAgentMailSerialized(ports, db, workspacePath, toAgent);
+        getMailboxDrainer().noteOutcome(workspacePath, toAgent, outcome);
+    }
+    catch (err) {
+        log('ERROR', `Decisions notice delivery errored for ${toAgent} (row ${row.id.slice(0, 8)}... stays held): ${err.message}`);
+    }
+    const stored = getMailboxById(db, row.id);
+    const fate = stored?.status === 'delivered' ? 'delivered' : `held (${stored?.reason ?? 'unknown'})`;
+    log('INFO', `Decisions notice ${fate} → ${toAgent} @ ${path.basename(workspacePath)} (mailbox ${row.id.slice(0, 8)}...)`);
+}
 /**
  * Persist a `held` mailbox row and write the Spec 1313 `held` send response. Used
  * for both dead-session cases (no live PTY, held `no-live-pty`). The row exists
@@ -2397,7 +2487,7 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
         const apiPath = subPath.replace(/^api\/?/, '');
         // GET /api/state - Return workspace state (architect, builders, shells)
         if (req.method === 'GET' && (apiPath === 'state' || apiPath === '')) {
-            return handleWorkspaceState(res, workspacePath);
+            return handleWorkspaceState(res, ctx, workspacePath);
         }
         // POST /api/tabs/shell - Create a new shell terminal
         if (req.method === 'POST' && apiPath === 'tabs/shell') {
@@ -2477,6 +2567,14 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
         if (req.method === 'GET' && apiPath === 'team') {
             return handleWorkspaceTeam(res, workspacePath);
         }
+        // GET /api/decisions, POST /api/decisions/rule — the Decisions tab (Spec 1819).
+        // The file is the configured one; neither route takes a path from the request.
+        if (req.method === 'GET' && apiPath === 'decisions') {
+            return handleDecisionsGet(res, workspacePath);
+        }
+        if (req.method === 'POST' && apiPath === 'decisions/rule') {
+            return handleDecisionsRule(req, res, workspacePath, ctx.log, message => notifyHubOfRuling(workspacePath, message, ctx.log));
+        }
         // GET /api/annotate/:tabId/* — Serve rich annotator template and sub-APIs
         const annotateMatch = apiPath.match(/^annotate\/([^/]+)(\/(.*))?$/);
         if (annotateMatch) {
@@ -2587,7 +2685,7 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
 // ============================================================================
 // Workspace API sub-handlers
 // ============================================================================
-async function handleWorkspaceState(res, workspacePath) {
+async function handleWorkspaceState(res, ctx, workspacePath) {
     // Rehydrate wsTerminals (SQLite sync + shellper reconnect) before reading.
     // Shared with /api/overview so both endpoints always see a freshly-reconciled
     // entry — see getRehydratedTerminalsEntry doc.
@@ -2610,13 +2708,14 @@ async function handleWorkspaceState(res, workspacePath) {
             return undefined;
         } })(),
         teamEnabled: await hasTeam(path.join(workspacePath, 'codev', 'team')),
+        decisionsEnabled: await decisionsFilePresent(workspacePath, ctx.log),
     };
     // Spec 761: build the architects collection from entry.architects (skip dead
     // sessions, main-first). Shared with /api/overview via `liveArchitects`
     // (Issue 1104) so both payloads list an identical set.
     // Spec 755: the scalar `state.architect` is preserved as a backward-compat
     // pointer to the same default architect (architects[0] when present).
-    const architects = liveArchitects(entry, manager);
+    const architects = liveArchitects(entry, manager, workspacePath);
     state.architects = architects;
     state.architect = architects[0] ?? null;
     // Add shells from refreshed cache