agent-nuvira 3.5.6 → 3.5.9

package/dist/web-dashboard/server.js

@@ -25,12 +25,13 @@ import { loadEnv } from '../utils/env.js';
 import { ConfigManager } from '../config/manager.js';
 import { parseRuntimeSpec } from '../mcp/runtime.js';
 import { runAllChecks } from '../cli/doctor.js';
+import { dependencySummary, probeRuntimeDependencies, } from '../learning/runtime-dependencies.js';
 import { getAutoRouter } from '../learning/auto-router.js';
 import { classifyEntries, } from '../learning/cost-classification.js';
 import { acceptanceSummary, collectLabelledTurns, serializeLabelledTurns, parseCorpusText, detectCorpusFormat, mergeImportedLabels, } from '../learning/acceptance-model.js';
 import { readDecisions, recallDecisions, reviseDecision } from '../learning/decision-log.js';
 import { degradedCallsFromTraces } from '../learning/reasoning-trace.js';
-import { withStrictModel } from '../inference/route-resolver.js';
+import { strictPinPolicy, withStrictModel } from '../inference/route-resolver.js';
 import { readRecallHits } from '../context/session-recall.js';
 import { getRouterPromotion } from '../learning/router-promotion.js';
 import { AUTH_CLEAR_THRESHOLD } from '../learning/key-hygiene.js';
@@ -55,6 +56,7 @@ import { isCuratedProcessEnvVar, normalizeProcessEnvValue, } from '../config/pro
 import { FRESH_DAYS, FRESHNESS_COPY, REACHABILITY_COPY, classifyFreshness, classifyReachability, } from '../learning/model-reachability.js';
 import { VERIFY_BACKLOG_DEFAULT_PER_RUN, VERIFY_BACKLOG_MAX_PER_RUN, getVerifyBacklogState, startVerifyBacklogRun, } from '../learning/model-verify-job.js';
 import { setToolsetEnabled } from '../tools/toolsets.js';
+import { ArtifactStore } from '../tools/artifact-store.js';
 import { setSkillEnabled } from '../learning/hub-skill-catalog.js';
 // I11 — dashboard channel send-test: the same registry/adapters `nuvira gateway
 // send` uses, so a Channels-tab test message behaves identically to the CLI.
@@ -68,6 +70,7 @@ import { ChannelDirectory, PLATFORM_ENV_VARS, platformConfigVars } from '../gate
 import { applyEnvToProcess, configurablePlatforms, envVarState, platformConfigStatus, platformEnvVarMeta, redactValue, writeEnvFile, } from '../gateway/platform-config.js';
 import { SERVICE_CATALOG, getServiceDefinition, } from '../config/service-catalog.js';
 import { probeService } from '../config/service-probe.js';
+import { pruneScratchWorkspaces } from '../config/scratch-workspace.js';
 // ─── Constants ──────────────────────────────────────────────────────────────
 const PORT = parseInt(envBuff('DASHBOARD_PORT') || '3030', 10);
 const HOST = envBuff('DASHBOARD_HOST') || '127.0.0.1';
@@ -119,6 +122,40 @@ let alwaysWatchQuota = false;
  * loadApiKeysFromConfig uses). Best-effort — a missing/corrupt config just
  * keeps the default (false = arm-on-connect only).
  */
+/**
+ * The content type for an artifact file: the recorded mime when there is one,
+ * otherwise the extension. Video and image types are the ones the panel renders
+ * inline, so a wrong type is a blank frame rather than a failed download.
+ */
+function artifactFileMime(file, recorded) {
+    if (recorded && /^[a-z]+\/[a-z0-9.+-]+$/i.test(recorded))
+        return recorded;
+    const ext = (file.split('.').pop() ?? '').toLowerCase();
+    const byExt = {
+        mp4: 'video/mp4',
+        webm: 'video/webm',
+        mov: 'video/quicktime',
+        mkv: 'video/x-matroska',
+        gif: 'image/gif',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        webp: 'image/webp',
+        svg: 'image/svg+xml',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        m4a: 'audio/mp4',
+        srt: 'application/x-subrip',
+        vtt: 'text/vtt',
+        json: 'application/json',
+        md: 'text/markdown',
+        txt: 'text/plain',
+        log: 'text/plain',
+        csv: 'text/csv',
+        pdf: 'application/pdf',
+    };
+    return byExt[ext] ?? 'application/octet-stream';
+}
 function loadAlwaysWatchQuotaFlag() {
     try {
         const configPath = resolveBuffConfigPath();
@@ -2807,14 +2844,42 @@ function buildServiceRow(def, canReadValues) {
         envVars,
     };
 }
+/**
+ * One runtime tool as the panel's payload. Exported for the server test, which
+ * asserts the panel is fed the same list `nuvira doctor` prints.
+ */
+export function runtimeToolSummary(status) {
+    return {
+        id: status.dependency.id,
+        label: status.dependency.label,
+        need: status.dependency.need,
+        present: status.present,
+        enables: status.dependency.enables,
+        neededBy: status.dependency.neededBy,
+        // A tool the machine ALREADY has gets no command on the wire, the same way
+        // `nuvira doctor` prints a fix only for what is missing: sending one anyway
+        // invites a user to reinstall something that is working.
+        installCommand: status.present ? null : status.installCommand,
+        note: status.dependency.note,
+        needsHumanInput: status.needsHumanInput,
+    };
+}
 /** Run ALL state checks — the dashboard command-runner payload. */
 async function runAdminChecks() {
     const configManager = new ConfigManager();
     const { system, enterprise } = await runAllChecks(configManager);
+    // The SAME declaration the CLI's `nuvira doctor`, the `--fix` installer and the
+    // setup scripts read, probed once for this payload. The rows are also in
+    // `system` (one check each) because a pass/warn verdict is what a check list
+    // is for; this is the actionable half — the command to copy, the
+    // recommended/optional split, and the caveat.
+    const statuses = probeRuntimeDependencies();
     return {
         system,
         enterprise,
         providers: buildAdminProviderSummary(configManager),
+        runtimeTools: statuses.map(runtimeToolSummary),
+        runtimeToolsSummary: dependencySummary(statuses),
         serverTime: Date.now(),
     };
 }
@@ -3312,6 +3377,52 @@ function handleRequest(req, res) {
         })();
         return;
     }
+    // ── An artifact's BYTES — how the Artifacts tab shows a rendered video rather
+    // than a filename. The path is looked up in OUR OWN artifact store by (session,
+    // artifact id) and is never taken from the query string, so a caller cannot ask
+    // this endpoint for an arbitrary file; a bad pair is a 404, not a read.
+    if (pathname === '/api/artifact-file') {
+        const sessionId = url.searchParams.get('session') ?? '';
+        const artifactId = url.searchParams.get('artifact') ?? '';
+        const artifact = artifactId
+            ? new ArtifactStore().read(sessionId).find((a) => a.id === artifactId)
+            : undefined;
+        if (!artifact || !artifact.path || !existsSync(artifact.path) || !statSync(artifact.path).isFile()) {
+            writeJson(res, 404, { ok: false, error: 'No such artifact file.' });
+            return;
+        }
+        const size = statSync(artifact.path).size;
+        const type = artifactFileMime(artifact.path, artifact.mime);
+        // Range support, because a <video> that cannot seek cannot be reviewed: a
+        // player asks for byte ranges the moment the user drags the scrubber.
+        const range = /^bytes=(\d*)-(\d*)$/.exec(req.headers.range ?? '');
+        if (range) {
+            const start = range[1] ? Number(range[1]) : 0;
+            const end = range[2] ? Math.min(Number(range[2]), size - 1) : size - 1;
+            if (start >= size || end < start) {
+                res.writeHead(416, { 'Content-Range': `bytes */${size}` });
+                res.end();
+                return;
+            }
+            res.writeHead(206, {
+                'Content-Type': type,
+                'Content-Length': String(end - start + 1),
+                'Content-Range': `bytes ${start}-${end}/${size}`,
+                'Accept-Ranges': 'bytes',
+                'Cache-Control': 'no-store',
+            });
+            createReadStream(artifact.path, { start, end }).pipe(res);
+            return;
+        }
+        res.writeHead(200, {
+            'Content-Type': type,
+            'Content-Length': String(size),
+            'Accept-Ranges': 'bytes',
+            'Cache-Control': 'no-store',
+        });
+        createReadStream(artifact.path).pipe(res);
+        return;
+    }
     if (pathname === '/api/benchmarks') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(readBenchmarkData()));
@@ -3391,7 +3502,17 @@ function handleRequest(req, res) {
             res.end(JSON.stringify(payload));
         }).catch((err) => {
             res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: String(err), system: [], enterprise: [], providers: [], serverTime: Date.now() }));
+            res.end(JSON.stringify({
+                error: String(err),
+                system: [],
+                enterprise: [],
+                providers: [],
+                // An empty list, not a missing one: the panel must be able to say
+                // "nothing reported" on a failed run rather than crash on undefined.
+                runtimeTools: [],
+                runtimeToolsSummary: 'unavailable — the checks run failed',
+                serverTime: Date.now(),
+            }));
         });
         return;
     }
@@ -7533,7 +7654,24 @@ function handleRequest(req, res) {
             // only" switch). Scoped to the turn with AsyncLocalStorage rather than a
             // process env write, because two sessions can run concurrently and a
             // global mutation would leak one user's pin into the other's turn.
-            const strict = body?.strict === true;
+            //
+            // READ AS A TRI-STATE (2026-10-16) — same three cases, same reasoning, as
+            // `worktree`/`resume` below. `true` holds the pin; `false` is this turn's
+            // EXPLICIT permission to substitute; ABSENT defers to the pin's own policy,
+            // where a request that NAMED a provider+model HOLDS (the pair `pinOf`
+            // records) and an Auto turn has no pair to hold.
+            //
+            // Collapsing absent into `false` — the previous `body?.strict === true` —
+            // was wrong on both sides. A pinned API request that never mentioned the
+            // flag was substituted by default, i.e. a pin read as a preference, which
+            // is the contract `strictPinPolicy` exists to end. And because the scope
+            // set here OUTRANKS the environment inside `withStrictModel`, a dashboard
+            // deployment running with `NUVIRA_STRICT_MODEL=1` was silently un-strict
+            // for every chat turn that left the flag out — the operator's own switch,
+            // quietly ignored.
+            const strict = typeof body?.strict === 'boolean'
+                ? body.strict
+                : strictPinPolicy(typeof provider === 'string' && typeof model === 'string');
             // WS5 (#27) — per-turn isolation and resume, from the GUI.
             //
             // Read as a strict TRI-state, because the three cases are genuinely
@@ -7598,13 +7736,51 @@ function handleRequest(req, res) {
              */
             const configuredCwd = resolveDashboardCwd();
             const { resolveTurnWorkspace, formatWorkspaceNoticeText } = await import('./workspace-resolution.js');
+            const { workspaceNeedForMissingFolder } = await import('./workspace-guard.js');
             const sessionProjectPath = chatConsole.get(sessionId)?.projectPath;
-            const workspace = resolveTurnWorkspace({
+            /**
+             * The same ladder, asked twice when the last rung is needed.
+             *
+             * WHY TWO PASSES. The scratch folder is a real directory on disk, so it is
+             * only created when the ladder has actually RUN OUT (nothing attached,
+             * nothing named in the message, no configured default) AND the ask needs
+             * somewhere to PUT new work. Creating it eagerly would leave an empty
+             * temporary folder behind on every turn that already had a folder, and
+             * handing it to a READ ask would be the kuttaaddon defect again — an empty
+             * folder cannot answer "assess this project".
+             */
+            const resolveWorkspaceNow = (scratchPath) => resolveTurnWorkspace({
                 ...(attachedPath ? { attachedPath } : {}),
                 ...(sessionProjectPath ? { sessionPath: sessionProjectPath } : {}),
                 ...(configuredCwd ? { configuredCwd } : {}),
                 message,
+                ...(scratchPath ? { scratchPath } : {}),
             });
+            let workspace = resolveWorkspaceNow();
+            /**
+             * What this ask needs a folder FOR — `'produce'` is the case a temporary
+             * folder can serve, `'read'` is the case it cannot (and keeps the folder
+             * prompt), `null` is plain chat, which needs none.
+             */
+            const missingWorkspaceNeed = workspace.path ? null : workspaceNeedForMissingFolder(message);
+            if (missingWorkspaceNeed === 'produce') {
+                // The scratch folder is offered through the SAME rule the gateway uses
+                // (`scratchWorkspaceForTurn`), so the two surfaces cannot disagree about
+                // when a temporary folder is the right answer — in particular about an
+                // ISOLATED turn, which a scratch folder can never serve: it has no base
+                // commit to diff against. There, this turn has no folder at all, so it
+                // falls through to the folder request below rather than isolating a
+                // directory the user never chose.
+                const { scratchWorkspaceForTurn } = await import('../config/scratch-workspace.js');
+                const { resolveIsolationRequest } = await import('../tools/worktree.js');
+                const scratch = scratchWorkspaceForTurn({
+                    key: sessionId,
+                    need: missingWorkspaceNeed,
+                    isolationAsked: resolveIsolationRequest({ worktree }).asked,
+                });
+                if (scratch)
+                    workspace = resolveWorkspaceNow(scratch);
+            }
             if (workspace.path) {
                 projectPath = workspace.path;
                 const bundle = getProjectBundle(workspace.path);
@@ -7622,24 +7798,23 @@ function handleRequest(req, res) {
              * 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 (!workspace.path) {
-                const { needsProjectAttachment, projectAttachmentPrompt, projectAttachmentFollowups } = await import('./workspace-guard.js');
-                if (needsProjectAttachment(message)) {
-                    writeJson(res, 200, {
-                        ok: true,
-                        sessionId,
-                        content: projectAttachmentPrompt(),
-                        followups: projectAttachmentFollowups(),
-                        provider: null,
-                        model: null,
-                        generationFailed: false,
-                        needsProject: true,
-                    });
-                    return;
-                }
+            // Still no workspace: either the ask must READ or CHANGE work that already
+            // exists (a temporary folder holds none of it), or the scratch folder could
+            // not be created. Both are the case for a folder request rather than an
+            // answer about the wrong tree. General chat — `null` — is unaffected.
+            if (!workspace.path && missingWorkspaceNeed !== null) {
+                const { projectAttachmentPrompt, projectAttachmentFollowups } = await import('./workspace-guard.js');
+                writeJson(res, 200, {
+                    ok: true,
+                    sessionId,
+                    content: projectAttachmentPrompt(),
+                    followups: projectAttachmentFollowups(),
+                    provider: null,
+                    model: null,
+                    generationFailed: false,
+                    needsProject: true,
+                });
+                return;
             }
             // P4 (revised) — a client DISCONNECT no longer cancels the turn. It used
             // to: the server treated `res` close as an abort, which meant a page
@@ -7677,6 +7852,14 @@ function handleRequest(req, res) {
             const result = await withStrictModel(strict, () => chatConsole.answer(sessionId, message, {
                 provider,
                 model,
+                // P8b — the STRICT half of the pin rides into the console so the
+                // CONVERSATION can remember it. `withStrictModel` above scopes it to
+                // this turn, but a conversation whose lock is forgotten between turns
+                // is a pin the user cannot actually rely on: measured live
+                // (trace-1792068695325-42wb1j) the pin survived a reload and the lock
+                // did not, so the engine handed the turn to another model with the
+                // user's "this model only" instruction never in force.
+                strict,
                 projectContext,
                 projectPath,
                 // Cluster G — carry the "no folder attached" state into the turn so a
@@ -7742,10 +7925,20 @@ function handleRequest(req, res) {
                             `your pinned ${requested} is ${pinnedClass} class, and this turn ran on ${served} (${servedClass} class).`;
                 }
                 else if (substituted) {
-                    routingNotice = `Auto routing took over: this turn ran on ${served} because your pinned ${requested} was not available. To work with ${requested} only, enable strict model mode.`;
+                    // Reachable now only when the turn EXPLICITLY allowed a substitute
+                    // (`strict: false`, the chat's lock switched off) or the deployment set
+                    // `NUVIRA_STRICT_MODEL=0`, because a named pair holds by default. So the
+                    // instruction names the two controls that actually release it, instead
+                    // of telling the user to enable something that is already the default.
+                    routingNotice = `Auto routing took over: this turn ran on ${served} because your pinned ${requested} was not available. To work with ${requested} only, hold the pin: turn the chat's lock back on, or set NUVIRA_STRICT_MODEL=1.`;
                 }
                 else if (result.generationFailed === true) {
-                    routingNotice = `Your pinned ${requested} could not complete this turn, so auto routing may hand the work to another model. To stay on this model only, enable strict model mode.`;
+                    // The turn ran on the pair the user pinned and stopped there. Saying
+                    // "auto routing may hand the work to another model" described the old
+                    // behaviour (a pinned turn followed the health ranking the moment its
+                    // pair returned an error) and would now be a lie: a pin waits on itself
+                    // and then asks. See `pinnedEscalation`.
+                    routingNotice = `Your pinned ${requested} did not answer, and nothing was sent to another model — the turn stopped instead of substituting. Retry it, or switch models.`;
                 }
             }
             // Did the offer we are about to send get a mechanism behind it? The client
@@ -8348,6 +8541,18 @@ export function createDashboardServer(opts) {
             handle.ipv6Twin = undefined;
         }
     }
+    // Scratch workspaces are temporary BY DEFINITION, so the ones nobody came back
+    // to are cleaned on boot rather than accumulating in the user's home for the
+    // life of the install (see `pruneScratchWorkspaces`). Best-effort: a failed
+    // prune must never stop the server from coming up.
+    try {
+        const removed = pruneScratchWorkspaces();
+        if (removed > 0)
+            console.log(`  🧹 Removed ${removed} expired scratch workspace(s)`);
+    }
+    catch {
+        /* best-effort */
+    }
     server.listen(bindPort, bindHost, () => {
         console.log(`\n  🌐 Agent-Nuvira Dashboard`);
         console.log(`  ─────────────────────────`);