agent-nuvira 3.3.13 → 3.3.14

package/dist/web-dashboard/server.js

@@ -25,6 +25,8 @@ import { loadEnv } from '../utils/env.js';
 import { ConfigManager } from '../config/manager.js';
 import { runAllChecks } from '../cli/doctor.js';
 import { getAutoRouter } from '../learning/auto-router.js';
+import { acceptanceSummary, collectLabelledTurns, serializeLabelledTurns, parseCorpusText, detectCorpusFormat, mergeImportedLabels, } from '../learning/acceptance-model.js';
+import { readDecisions, recallDecisions, reviseDecision } from '../learning/decision-log.js';
 import { withStrictModel } from '../inference/route-resolver.js';
 import { readRecallHits } from '../context/session-recall.js';
 import { getRouterPromotion } from '../learning/router-promotion.js';
@@ -2618,6 +2620,25 @@ function resolveDashboardCwd(configManager) {
         return undefined;
     }
 }
+/**
+ * The directory a decisions request targets: a directory the client named that
+ * actually exists, else the configured workspace (`dashboard.cwd`), else the
+ * process cwd. Never returns a path that is not a directory, so a read or a
+ * revise can only ever touch a real project's own `.nuvira/` store.
+ */
+function resolveDecisionDir(requested) {
+    const named = typeof requested === 'string' ? requested.trim() : '';
+    if (named) {
+        try {
+            if (existsSync(named) && statSync(named).isDirectory())
+                return resolve(named);
+        }
+        catch {
+            // Unusable path — fall through to the configured default.
+        }
+    }
+    return resolveDashboardCwd() ?? process.cwd();
+}
 function summarizeProvider(type, configManager) {
     const c = (configManager.getAll().providers || {})[type];
     const envVar = PROVIDER_ENV_VARS[type];
@@ -3120,7 +3141,9 @@ function handleRequest(req, res) {
             writeJson(res, 200, {
                 ok: true,
                 file: m.hookDeclarationsFile(),
-                hooks: m.getHookDeclarations(),
+                // Built-in starter hooks (disabled) are merged in for DISPLAY; the
+                // runtime still evaluates only the in-force user set.
+                hooks: m.listHookDeclarations(),
                 events: m.HOOK_EVENTS,
                 eventDescriptions: m.HOOK_EVENT_DESCRIPTIONS,
                 actionKinds: m.HOOK_ACTION_KINDS,
@@ -5141,6 +5164,149 @@ function handleRequest(req, res) {
         res.end(JSON.stringify(readModelRegistryData()));
         return;
     }
+    // GET /api/acceptance (Bundle 32) — the acceptance corpus at a glance: labelled
+    // counts, class balance, the per-pair record, and whether the read-only fit has
+    // enough to train. READ is open like the other model endpoints — it carries only
+    // aggregate counts and a fit that nothing routes on. Always 200; an unavailable
+    // store degrades to an empty summary rather than a spinner the UI never leaves.
+    if (pathname === '/api/acceptance' && req.method === 'GET') {
+        try {
+            const s = acceptanceSummary();
+            writeJson(res, 200, {
+                labelled: s.labelled,
+                accepted: s.accepted,
+                rejected: s.rejected,
+                bySource: s.bySource,
+                byPair: s.byPair,
+                fit: s.fit.ok
+                    ? {
+                        ok: true,
+                        n: s.fit.model.n,
+                        positives: s.fit.model.positives,
+                        negatives: s.fit.model.negatives,
+                        featureNames: s.fit.model.featureNames,
+                        weights: s.fit.model.weights,
+                        bias: s.fit.model.bias,
+                    }
+                    : {
+                        ok: false,
+                        reason: s.fit.reason,
+                        n: s.fit.n,
+                        positives: s.fit.positives,
+                        negatives: s.fit.negatives,
+                    },
+            });
+        }
+        catch {
+            writeJson(res, 200, {
+                labelled: 0,
+                accepted: 0,
+                rejected: 0,
+                bySource: {},
+                byPair: {},
+                fit: { ok: false, reason: 'acceptance model unavailable', n: 0, positives: 0, negatives: 0 },
+            });
+        }
+        return;
+    }
+    // GET /api/acceptance/export (Bundle 34) — the labelled corpus as a download, the
+    // SAME rows `nuvira rate --export` writes, so the CLI and the dashboard ship an
+    // identical file. `?format=csv` selects CSV; JSON is the default.
+    if (pathname === '/api/acceptance/export' && req.method === 'GET') {
+        try {
+            const fmtParam = (new URL(req.url ?? '', 'http://localhost').searchParams.get('format') || '').toLowerCase();
+            const fmt = fmtParam === 'csv' ? 'csv' : 'json';
+            const text = serializeLabelledTurns(collectLabelledTurns(), fmt);
+            res.writeHead(200, {
+                'Content-Type': fmt === 'csv' ? 'text/csv; charset=utf-8' : 'application/json; charset=utf-8',
+                'Content-Disposition': `attachment; filename="acceptance-corpus.${fmt}"`,
+            });
+            res.end(text);
+        }
+        catch {
+            writeJson(res, 500, { error: 'Could not export the acceptance corpus' });
+        }
+        return;
+    }
+    // POST /api/acceptance/import { text, format? } (Bundle 34) — merge a corpus
+    // collected elsewhere into the local store. The browser reads the file and posts
+    // its TEXT, so the endpoint needs no multipart handling. Deduped by trace, so
+    // re-importing is idempotent. Nothing routes on these labels.
+    if (pathname === '/api/acceptance/import' && req.method === 'POST') {
+        void (async () => {
+            const body = await readJsonBody(req);
+            const text = body && typeof body.text === 'string' ? body.text : '';
+            if (!text.trim()) {
+                writeJson(res, 400, { error: 'No corpus text supplied — POST { text, format? }' });
+                return;
+            }
+            const fmt = body && (body.format === 'csv' || body.format === 'json')
+                ? body.format
+                : detectCorpusFormat(undefined, text);
+            const rows = parseCorpusText(text, fmt);
+            if (rows.length === 0) {
+                writeJson(res, 400, { error: 'No labelled turns found in the supplied corpus' });
+                return;
+            }
+            const counts = mergeImportedLabels(rows);
+            writeJson(res, 200, { ok: true, imported: rows.length, ...counts });
+        })();
+        return;
+    }
+    // ── The project's decision log (Bundle 36) ──────────────────────────────
+    //
+    // The decisions a project's turns asked the user to make (written by
+    // `ask_user`). READ-ONLY apart from `revise`, which rewrites ONE record in the
+    // project's own `.nuvira/` store. The dashboard is the same surface the CLI is
+    // (`nuvira decisions`), reading the same files, so the two cannot disagree.
+    //
+    // GET /api/decisions?dir=<path>&for=<text>&limit=<n>
+    //   dir defaults to the configured workspace (`dashboard.cwd`), then the
+    //   process cwd — the SAME fallback the project picker uses.
+    if (pathname === '/api/decisions' && req.method === 'GET') {
+        const dir = resolveDecisionDir(url.searchParams.get('dir'));
+        const forText = (url.searchParams.get('for') ?? '').trim();
+        try {
+            if (forText) {
+                const limit = Math.max(1, Math.min(50, Number(url.searchParams.get('limit')) || 5));
+                writeJson(res, 200, { ok: true, dir, relevant: true, decisions: recallDecisions(dir, forText, limit) });
+            }
+            else {
+                writeJson(res, 200, { ok: true, dir, relevant: false, decisions: readDecisions(dir) });
+            }
+        }
+        catch {
+            // Best-effort: an unreadable store is an empty log, never a 500.
+            writeJson(res, 200, { ok: true, dir, relevant: Boolean(forText), decisions: [] });
+        }
+        return;
+    }
+    // POST /api/decisions/revise { id, answer, note?, dir? } — change ONE decision,
+    // keeping the previous answer in its history. Open, like the other turn/feedback
+    // surfaces: it records a choice ABOUT this project rather than changing config.
+    if (pathname === '/api/decisions/revise' && req.method === 'POST') {
+        void (async () => {
+            const body = await readJsonBody(req);
+            const id = typeof body?.id === 'string' ? body.id.trim() : '';
+            const answer = typeof body?.answer === 'string' ? body.answer.trim() : '';
+            const note = typeof body?.note === 'string' && body.note.trim() ? body.note.trim() : undefined;
+            if (!id || !answer) {
+                writeJson(res, 400, { ok: false, error: 'Expected { id, answer }.' });
+                return;
+            }
+            // The workspace the page is showing — a directory that EXISTS, else the
+            // configured default. A revise only ever writes inside that directory's own
+            // `.nuvira/` store.
+            const dir = resolveDecisionDir(typeof body?.dir === 'string' ? body.dir : undefined);
+            const revised = reviseDecision(dir, id, answer, note);
+            if (!revised) {
+                writeJson(res, 404, { ok: false, error: `No decision with id ${id} for this workspace.` });
+                return;
+            }
+            writeJson(res, 200, { ok: true, decision: revised });
+        })();
+        return;
+    }
     // Model Discovery Timeline endpoint
     if (pathname === '/api/model-timeline') {
         try {
@@ -5288,6 +5454,32 @@ function handleRequest(req, res) {
         res.end(JSON.stringify(readTracesData()));
         return;
     }
+    // The USER's verdict on a turn — the one label a quality signal can be fit to.
+    // POST /api/traces/:id/verdict { verdict: 'accepted' | 'rejected' }.
+    //
+    // Open, like the other turn surfaces: it records feedback ABOUT a turn rather
+    // than changing configuration. It writes through the SAME module the CLI uses
+    // (`learning/turn-feedback.ts`), so the two surfaces cannot drift into two
+    // different notions of what a verdict means.
+    if (pathname.startsWith('/api/traces/') && pathname.endsWith('/verdict') && req.method === 'POST') {
+        void (async () => {
+            const traceId = decodeURIComponent(pathname.slice('/api/traces/'.length, -'/verdict'.length));
+            const body = await readJsonBody(req);
+            const verdict = body?.verdict;
+            if (verdict !== 'accepted' && verdict !== 'rejected') {
+                writeJson(res, 400, { ok: false, error: "Expected { verdict: 'accepted' | 'rejected' }." });
+                return;
+            }
+            const { rateTurn } = await import('../learning/turn-feedback.js');
+            const result = rateTurn({ verdict, traceId, source: 'dashboard' });
+            if (!result.ok) {
+                writeJson(res, 404, { ok: false, error: result.error });
+                return;
+            }
+            writeJson(res, 200, { ok: true, rated: result.rated });
+        })();
+        return;
+    }
     if (pathname.startsWith('/api/traces/')) {
         const traceId = decodeURIComponent(pathname.slice('/api/traces/'.length));
         const trace = readTraceDetail(traceId);
@@ -5300,6 +5492,117 @@ function handleRequest(req, res) {
         res.end(JSON.stringify(trace));
         return;
     }
+    // ── Bundle 37/39/40 — one picture of consent, and how much the harness spoke ──
+    // Open like the other read paths: these expose policy and counts, never data.
+    if (pathname === '/api/gates') {
+        void (async () => {
+            const { summarizeGateFriction } = await import('../learning/gate-friction.js');
+            writeJson(res, 200, { ok: true, ...summarizeGateFriction(readTracesFile()) });
+        })();
+        return;
+    }
+    if (pathname === '/api/consent') {
+        void (async () => {
+            const { consentPicture } = await import('../learning/consent-picture.js');
+            writeJson(res, 200, { ok: true, picture: consentPicture() });
+        })();
+        return;
+    }
+    // The live session grants (Bundle 37a). The console owns every session's plan
+    // store, so it is the one place that can see them all.
+    if (pathname === '/api/session-grants') {
+        writeJson(res, 200, { ok: true, grants: chatConsole.listSessionGrants() });
+        return;
+    }
+    // Ending a grant is the user asking to be asked again — it can only make the
+    // agent MORE conservative, so it needs no further confirmation.
+    if (pathname === '/api/session-grants/clear' && req.method === 'POST') {
+        void (async () => {
+            const body = await readJsonBody(req);
+            const sessionId = typeof body?.sessionId === 'string' ? body.sessionId : '';
+            if (!sessionId) {
+                writeJson(res, 400, { ok: false, error: 'sessionId is required.' });
+                return;
+            }
+            writeJson(res, 200, { ok: true, cleared: chatConsole.revokeSessionGrant(sessionId) });
+        })();
+        return;
+    }
+    // ── Capability readiness — what the agent can do on THIS machine ────────
+    // Open like the other read paths: it exposes capability declarations and PATH
+    // facts, never user data. The page pairs it with `/api/session-grants`, so the
+    // grants shown and the grants ended are read and written through one source.
+    if (pathname === '/api/capabilities' && req.method === 'GET') {
+        void (async () => {
+            const { capabilityReadiness } = await import('../learning/capability-readiness.js');
+            const { listLearnedCommands } = await import('../learning/learned-commands.js');
+            writeJson(res, 200, { ok: true, ...capabilityReadiness(), learnedCommands: listLearnedCommands() });
+        })();
+        return;
+    }
+    // Record (or replace) a per-OS command. A WRITE, so gated like the other
+    // capability-changing surfaces. The store is keyed by (verb, os) and isolated
+    // by $NUVIRA_CONFIG_DIR — the same store `tool_search record` writes.
+    if (pathname === '/api/capabilities/commands' && req.method === 'POST') {
+        void (async () => {
+            const session = adminSessions.validate(bearerToken(req));
+            if (!session) {
+                writeJson(res, 401, { ok: false, error: 'Not authenticated — log in first.' });
+                return;
+            }
+            if (!roleCan(session.role, 'routing.operate')) {
+                writeJson(res, 403, {
+                    ok: false,
+                    error: `Access denied — role '${session.role}' cannot change capability commands (requires admin or operator).`,
+                });
+                return;
+            }
+            const body = await readJsonBody(req);
+            const verb = typeof body?.verb === 'string' ? body.verb.trim() : '';
+            const commandText = typeof body?.command === 'string' ? body.command.trim() : '';
+            const note = typeof body?.note === 'string' ? body.note.trim() : '';
+            if (!verb || !commandText) {
+                writeJson(res, 400, { ok: false, error: 'A verb and a command are required.' });
+                return;
+            }
+            const { recordLearnedCommand, listLearnedCommands } = await import('../learning/learned-commands.js');
+            const { leadingBinary } = await import('../learning/command-adaptation.js');
+            const bin = leadingBinary(commandText);
+            const entry = recordLearnedCommand({
+                verb,
+                command: commandText,
+                ...(bin ? { binary: bin } : {}),
+                ...(note ? { note } : {}),
+            });
+            writeJson(res, 200, { ok: true, recorded: entry, commands: listLearnedCommands() });
+        })();
+        return;
+    }
+    if (pathname === '/api/capabilities/commands/forget' && req.method === 'POST') {
+        void (async () => {
+            const session = adminSessions.validate(bearerToken(req));
+            if (!session) {
+                writeJson(res, 401, { ok: false, error: 'Not authenticated — log in first.' });
+                return;
+            }
+            if (!roleCan(session.role, 'routing.operate')) {
+                writeJson(res, 403, {
+                    ok: false,
+                    error: `Access denied — role '${session.role}' cannot change capability commands (requires admin or operator).`,
+                });
+                return;
+            }
+            const body = await readJsonBody(req);
+            const verb = typeof body?.verb === 'string' ? body.verb.trim() : '';
+            if (!verb) {
+                writeJson(res, 400, { ok: false, error: 'A verb is required.' });
+                return;
+            }
+            const { forgetLearnedCommand, listLearnedCommands } = await import('../learning/learned-commands.js');
+            writeJson(res, 200, { ok: true, forgotten: forgetLearnedCommand(verb), commands: listLearnedCommands() });
+        })();
+        return;
+    }
     if (pathname === '/api/routing') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(readRoutingInsights()));
@@ -6789,10 +7092,24 @@ function handleRequest(req, res) {
                 : undefined;
             /**
              * The workspace for this turn, in priority order: the folder the user
-             * ATTACHED, then the operator-configured `dashboard.cwd`, and otherwise
-             * NOTHING.
+             * ATTACHED, the one this CONVERSATION attached earlier, one the user NAMED
+             * in their own message, then the operator-configured `dashboard.cwd` — and
+             * otherwise NOTHING. See `resolveTurnWorkspace` (Cluster G); the rule lives
+             * in that module so it can be tested without an HTTP server, and this call
+             * site only carries it out.
              *
-             * "Nothing" is the important case. The turn used to fall back to the
+             * The two additions matter because both were reported failures:
+             * - The SESSION's path is read back. The composer re-sends `projectPath`
+             *   from React state only, so a reload mid-conversation (or an attach whose
+             *   response the UI never got) left the server folder-less and answering
+             *   every turn with "I need a project folder" — the user's "agent keep
+             *   refusing even after i attach the folder".
+             * - A folder TYPED IN THE MESSAGE is adopted. The guard already treated a
+             *   typed absolute path as specific enough not to ask about; it then
+             *   discarded it. "as user gives folder either path via chat … we can use
+             *   it" is that second half.
+             *
+             * "Nothing" remains the important case. The turn used to fall back to the
              * dashboard server's own working directory, so a service started from the
              * home folder answered "assess this project" by listing `~` and describing
              * whatever unrelated checkout it found there — a confident answer about a
@@ -6800,17 +7117,35 @@ function handleRequest(req, res) {
              * guard below turns that into a request for a folder.
              */
             const configuredCwd = resolveDashboardCwd();
-            const effectiveProjectPath = attachedPath ?? configuredCwd;
-            if (effectiveProjectPath) {
-                projectPath = effectiveProjectPath;
-                const bundle = getProjectBundle(effectiveProjectPath);
-                if (bundle)
-                    projectContext = formatProjectText(bundle);
+            const { resolveTurnWorkspace, formatWorkspaceNoticeText } = await import('./workspace-resolution.js');
+            const sessionProjectPath = chatConsole.get(sessionId)?.projectPath;
+            const workspace = resolveTurnWorkspace({
+                ...(attachedPath ? { attachedPath } : {}),
+                ...(sessionProjectPath ? { sessionPath: sessionProjectPath } : {}),
+                ...(configuredCwd ? { configuredCwd } : {}),
+                message,
+            });
+            if (workspace.path) {
+                projectPath = workspace.path;
+                const bundle = getProjectBundle(workspace.path);
+                if (bundle) {
+                    projectContext = formatProjectText(bundle, {
+                        source: workspace.source,
+                        ...(workspace.notice ? { notice: workspace.notice } : {}),
+                    });
+                }
             }
+            /**
+             * The warning the response carries when the turn is NOT in the user's own
+             * folder, so the surface can say where the work went instead of the user
+             * discovering it. Absent for the attached case — the user's own folder
+             * needs no caption.
+             */
+            const workspaceNotice = formatWorkspaceNoticeText(workspace);
             // No workspace and no configured default: an ask that names a project, or
             // that produces/consumes files, gets a folder request instead of an answer
             // about the wrong tree. General chat is unaffected.
-            if (!effectiveProjectPath) {
+            if (!workspace.path) {
                 const { needsProjectAttachment, projectAttachmentPrompt, projectAttachmentFollowups } = await import('./workspace-guard.js');
                 if (needsProjectAttachment(message)) {
                     writeJson(res, 200, {
@@ -6864,6 +7199,10 @@ function handleRequest(req, res) {
                 model,
                 projectContext,
                 projectPath,
+                // Cluster G — carry the "no folder attached" state into the turn so a
+                // write asks WHERE instead of landing in whatever directory the
+                // dashboard process was started from (see `unscopedWriteRefusal`).
+                ...(workspace.unscoped ? { unscopedWorkspace: true } : {}),
                 attachments,
                 ...(worktree === undefined ? {} : { worktree }),
                 ...(keepWorktree === undefined ? {} : { keepWorktree }),
@@ -6936,6 +7275,18 @@ function handleRequest(req, res) {
                 provider: result.provider ?? null,
                 model: result.model ?? null,
                 ...(routingNotice ? { routingNotice } : {}),
+                // Cluster G — where this turn's workspace came from, when it was not the
+                // folder the user attached: the session's earlier attachment, a folder
+                // they named in the message, or the operator's default. The client shows
+                // it so a file landing somewhere unexpected is explained, not discovered.
+                ...(workspaceNotice ? { workspaceNotice } : {}),
+                // The resolved workspace itself, so the client can ATTACH it to the chat
+                // and highlight it. A folder the user named in a message is a folder they
+                // want to keep working in; leaving the composer's chip empty would ask
+                // them for it again on the next turn.
+                ...(workspace.path && workspace.source !== 'attached'
+                    ? { workspacePath: workspace.path, workspaceSource: workspace.source }
+                    : {}),
                 // WS1 — the findings this turn recorded, with the gate's verdicts, so
                 // a dashboard client reads the same wire form the CLI, the gateway and
                 // the subagent report (the GUI card is a rendering decision; the FACT