coding-agent-harness 1.0.8 → 1.1.0

package/dist/lib/dashboard-workbench.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Dashboard workbench HTTP handlers stay behavior-first until workbench request/response types are modeled.
 import crypto from "node:crypto";
 import { spawn } from "node:child_process";
@@ -6,24 +5,26 @@ import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
 import { URL } from "node:url";
-import { confirmTaskReview } from "./task-lifecycle.mjs";
-import { createLessonSedimentationTask } from "./task-lesson-sedimentation.mjs";
+import { confirmTaskReview, finalizeDeferredTaskReviewConfirmation, updateTaskLifecycle } from "./task-lifecycle.mjs";
+import { createAggregateLessonSedimentationTask, createLessonSedimentationTask } from "./task-lesson-sedimentation.mjs";
 import { normalizeTarget } from "./core-shared.mjs";
+import { beginGovernanceSync, commitGovernanceSync, releaseGovernanceSync } from "./governance-sync.mjs";
 import { dashboardWatchRoots } from "./harness-paths.mjs";
-import { collectTasks } from "./task-scanner.mjs";
+import { createScannerTaskRepository } from "./task-repository.mjs";
 import { writeDashboardFolder } from "./dashboard-data.mjs";
 import { checkPresetPackage, installPresetPackage, listPresetPackages, seedBundledPresets, uninstallPresetPackage, } from "./preset-registry.mjs";
-const jsonHeaders = { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" };
-export async function serveDashboardWorkbench(outDir, targetInput, { host = "127.0.0.1", port = 0, localeOverride = "", autoRefresh = false, open = false, label = "dashboard workbench", recoverGeneratedDashboard = false } = {}) {
+const jsonHeaders = { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "connection": "close" };
+export async function serveDashboardWorkbench(outDir, targetInput, { host = "127.0.0.1", port = 0, localeOverride = "", autoRefresh = false, open = false, label = "dashboard workbench", recoverGeneratedDashboard = false, replaceExistingDashboardOutput = false } = {}) {
     if (host !== "127.0.0.1")
         throw new Error("dashboard workbench only supports --host 127.0.0.1");
     const target = normalizeTarget(targetInput);
+    const taskRepository = createScannerTaskRepository(target);
     const outputDir = path.resolve(outDir);
     const csrfToken = crypto.randomBytes(24).toString("hex");
     const options = localeOverride ? { localeOverride } : {};
     let snapshotVersion = Date.now();
     const regenerate = () => {
-        writeDashboardFolder(outputDir, targetInput, { ...options, workbenchRuntime: true, recoverGeneratedDashboard });
+        writeDashboardFolder(outputDir, targetInput, { ...options, workbenchRuntime: true, recoverGeneratedDashboard, replaceExistingDashboardOutput });
         snapshotVersion = Date.now();
     };
     regenerate();
@@ -37,7 +38,7 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
                 writeJson(response, 200, {
                     mode: "workbench",
                     csrfToken,
-                    writableActions: ["review-complete", "lesson-sedimentation-task", "preset-check", "preset-install", "preset-seed", "preset-uninstall"],
+                    writableActions: ["review-complete", "review-complete-bulk", "task-complete", "lesson-sedimentation-task", "lesson-sedimentation-bulk", "preset-check", "preset-install", "preset-seed", "preset-uninstall"],
                     target: target.projectRoot,
                     autoRefresh: autoRefresh === true,
                     snapshotVersion,
@@ -48,7 +49,7 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
                 assertTrustedWorkbenchRequest(request, { origin, csrfToken });
                 const body = await readJsonBody(request);
                 const taskId = String(body.taskId || "");
-                const task = collectTasks(target).find((item) => item.id === taskId);
+                const task = findWorkbenchTask(taskRepository, taskId);
                 if (!task) {
                     writeJson(response, 404, { error: "Task not found" });
                     return;
@@ -71,12 +72,100 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
                 writeJson(response, 200, result);
                 return;
             }
+            if (requestUrl.pathname === "/api/tasks/task-complete" && request.method === "POST") {
+                assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+                const body = await readJsonBody(request);
+                const taskId = String(body.taskId || "");
+                const task = findWorkbenchTask(taskRepository, taskId);
+                if (!task) {
+                    writeJson(response, 404, { error: "Task not found" });
+                    return;
+                }
+                if (taskHasPendingLessonWork(task)) {
+                    writeJson(response, 409, closeoutRejectionPayload(task, "Lesson candidate promotion or sedimentation work must be resolved before closeout."));
+                    return;
+                }
+                if (!taskReadyForCloseout(task)) {
+                    writeJson(response, 409, closeoutRejectionPayload(task));
+                    return;
+                }
+                const result = updateTaskLifecycle(target.projectRoot, taskId, {
+                    event: "task-complete",
+                    state: "done",
+                    message: body.message || "closed from dashboard workbench",
+                    evidence: body.evidence || "",
+                });
+                regenerate();
+                writeJson(response, 200, result);
+                return;
+            }
+            if (requestUrl.pathname === "/api/tasks/review-complete-bulk" && request.method === "POST") {
+                assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+                const body = await readJsonBody(request);
+                const requestedTaskIds = Array.isArray(body.taskIds) ? body.taskIds.map((id) => String(id || "").trim()).filter(Boolean) : [];
+                const taskIds = uniqueValues(requestedTaskIds);
+                if (taskIds.length === 0) {
+                    writeJson(response, 400, { error: "No review tasks selected" });
+                    return;
+                }
+                const results = [];
+                for (const taskId of taskIds) {
+                    const task = findWorkbenchTask(taskRepository, taskId);
+                    if (!task) {
+                        results.push({ taskId, ok: false, status: 404, error: "Task not found" });
+                        continue;
+                    }
+                    if (!isTaskInReviewQueue(task)) {
+                        const payload = reviewQueueRejectionPayload(task);
+                        results.push({ taskId, ok: false, status: 409, ...payload });
+                        continue;
+                    }
+                    if (task.reviewStatus === "confirmed") {
+                        results.push({ taskId, ok: false, status: 409, error: "Review is already confirmed." });
+                        continue;
+                    }
+                    try {
+                        const result = confirmTaskReview(target.projectRoot, taskId, {
+                            reviewer: body.reviewer || "Human Reviewer",
+                            message: body.message || "bulk confirmed from dashboard workbench",
+                            evidence: body.evidence || "",
+                            confirmText: task.shortId || task.id,
+                            deferCommit: true,
+                        });
+                        results.push({ taskId, ok: true, status: 200, audit: result.audit, task: { id: result.task?.id || taskId } });
+                    }
+                    catch (error) {
+                        results.push({ taskId, ok: false, status: errorStatus(error), ...errorPayload(error) });
+                    }
+                }
+                const confirmed = results.filter((result) => result.ok).length;
+                const failed = results.length - confirmed;
+                if (confirmed > 0) {
+                    const allowedPaths = uniqueValues(results.filter((result) => result.ok).flatMap((result) => result.audit?.allowedPaths || []));
+                    const confirmCommit = commitWorkbenchBatch(target, allowedPaths, { operation: "review-complete-bulk", message: "chore: confirm selected reviews" });
+                    for (const result of results.filter((item) => item.ok)) {
+                        finalizeDeferredTaskReviewConfirmation(target.projectRoot, result.taskId, { commitSha: confirmCommit.commitSha });
+                    }
+                    const auditCommit = commitWorkbenchBatch(target, allowedPaths, { operation: "review-complete-bulk-audit", message: "chore: record selected review confirmation audit" });
+                    for (const result of results.filter((item) => item.ok)) {
+                        result.audit = {
+                            ...result.audit,
+                            commitSha: confirmCommit.commitSha,
+                            auditCommitSha: auditCommit.commitSha,
+                            auditStatus: "committed",
+                            allowedPaths,
+                        };
+                    }
+                }
+                writeJson(response, confirmed > 0 ? 200 : 409, { ok: failed === 0, confirmed, failed, results });
+                return;
+            }
             if (requestUrl.pathname === "/api/tasks/lesson-sedimentation" && request.method === "POST") {
                 assertTrustedWorkbenchRequest(request, { origin, csrfToken });
                 const body = await readJsonBody(request);
                 const taskId = String(body.taskId || "");
                 const candidateId = String(body.candidateId || "");
-                const task = collectTasks(target).find((item) => item.id === taskId);
+                const task = findWorkbenchTask(taskRepository, taskId);
                 if (!task) {
                     writeJson(response, 404, { error: "Task not found" });
                     return;
@@ -92,6 +181,40 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
                 writeJson(response, 200, result);
                 return;
             }
+            if (requestUrl.pathname === "/api/tasks/lesson-sedimentation-bulk" && request.method === "POST") {
+                assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+                const body = await readJsonBody(request);
+                const selections = normalizeBulkLessonSelections(body.selections);
+                if (selections.length === 0) {
+                    writeJson(response, 400, { error: "No lesson candidates selected" });
+                    return;
+                }
+                try {
+                    const result = createAggregateLessonSedimentationTask(target.projectRoot, selections, {
+                        title: body.title || "",
+                    });
+                    const results = selections.map((selection) => ({
+                        ...selection,
+                        ok: true,
+                        status: 200,
+                        followUpTask: result.followUpTask,
+                    }));
+                    writeJson(response, 200, {
+                        ok: true,
+                        created: 1,
+                        candidates: result.candidates.length,
+                        failed: 0,
+                        followUpTask: result.followUpTask,
+                        prompt: result.prompt,
+                        governance: result.governance,
+                        results,
+                    });
+                }
+                catch (error) {
+                    writeJson(response, errorStatus(error), { ok: false, created: 0, candidates: selections.length, failed: selections.length, ...errorPayload(error) });
+                }
+                return;
+            }
             if (requestUrl.pathname === "/api/presets/check" && request.method === "POST") {
                 assertTrustedWorkbenchRequest(request, { origin, csrfToken });
                 const body = await readJsonBody(request);
@@ -159,16 +282,19 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
                 writeJson(response, 405, { error: "Method not allowed" });
                 return;
             }
+            if (request.method === "GET" && isDashboardDataRequest(requestUrl.pathname))
+                regenerate();
             serveStaticFile(response, outputDir, requestUrl.pathname, request.method === "HEAD");
         }
         catch (error) {
-            const status = error.status || (/CSRF|Origin|Host/.test(error.message) ? 403 : 400);
+            const message = errorMessage(error);
+            const status = errorStatus(error, /CSRF|Origin|Host/.test(message) ? 403 : 400);
             writeJson(response, status, errorPayload(error));
         }
     });
     await new Promise((resolve, reject) => {
         server.once("error", reject);
-        server.listen(Number(port), host, resolve);
+        server.listen(Number(port), host, () => resolve());
     });
     const address = server.address();
     const actualPort = typeof address === "object" && address ? address.port : port;
@@ -194,9 +320,83 @@ function normalizePresetScope(value) {
         throw new Error(`Invalid preset scope: ${scope}`);
     return scope;
 }
+function isDashboardDataRequest(urlPath) {
+    return urlPath === "/assets/dashboard-data.js" || urlPath.startsWith("/data/");
+}
+function commitWorkbenchBatch(target, allowedPaths, { operation, message }) {
+    const paths = uniqueValues(allowedPaths || []);
+    const context = beginGovernanceSync(target, {
+        operation,
+        allowDirtyWorktree: true,
+        allowedRelativePaths: paths,
+        allowDirtyWriteScope: true,
+    });
+    try {
+        return commitGovernanceSync(context, paths, { message });
+    }
+    finally {
+        releaseGovernanceSync(context);
+    }
+}
+function uniqueValues(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function normalizeBulkLessonSelections(rawSelections) {
+    if (!Array.isArray(rawSelections))
+        return [];
+    const seen = new Set();
+    const result = [];
+    for (const selection of rawSelections) {
+        const taskId = String(selection?.taskId || "").trim();
+        const candidateId = String(selection?.candidateId || "").trim();
+        if (!taskId || !candidateId)
+            continue;
+        const key = `${taskId}\n${candidateId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push({ taskId, candidateId });
+    }
+    return result;
+}
+function findWorkbenchTask(repository, taskId) {
+    try {
+        return repository.get({ id: taskId });
+    }
+    catch {
+        return undefined;
+    }
+}
 function isTaskInReviewQueue(task) {
     return task?.reviewQueueState === "ready-to-confirm" && Array.isArray(task?.taskQueues) && task.taskQueues.includes("review");
 }
+function taskHasPendingLessonWork(task) {
+    const queues = Array.isArray(task?.taskQueues) ? task.taskQueues : [];
+    const candidateRows = Array.isArray(task?.lessonCandidateRows) ? task.lessonCandidateRows : [];
+    return queues.includes("lessons") ||
+        task?.lessonCandidateStatus === "needs-promotion" ||
+        task?.lessonCandidatePromotionState === "queued" ||
+        candidateRows.some((candidate) => ["ready-for-review", "needs-promotion"].includes(String(candidate?.status || "")));
+}
+function taskReadyForCloseout(task) {
+    if (!task)
+        return false;
+    if (task.reviewStatus !== "confirmed")
+        return false;
+    if (task.closeoutStatus === "closed")
+        return false;
+    if (taskHasPendingLessonWork(task))
+        return false;
+    return ["no-candidate-accepted", "promoted", "rejected"].includes(String(task.lessonCandidateStatus || ""));
+}
 function reviewQueueRejectionPayload(task) {
     return {
         error: "Review completion is only available for tasks in the review queue.",
@@ -208,6 +408,18 @@ function reviewQueueRejectionPayload(task) {
         taskId: task?.id || "",
     };
 }
+function closeoutRejectionPayload(task, error = "Task closeout is only available after human review is confirmed and Lesson routing is complete.") {
+    return {
+        error,
+        closeoutStatus: task?.closeoutStatus || "unknown",
+        lifecycleState: task?.lifecycleState || "unknown",
+        reviewStatus: task?.reviewStatus || "unknown",
+        taskQueues: Array.isArray(task?.taskQueues) ? task.taskQueues : [],
+        lessonCandidateStatus: task?.lessonCandidateStatus || "unknown",
+        lessonCandidatePromotionState: task?.lessonCandidatePromotionState || "unknown",
+        taskId: task?.id || "",
+    };
+}
 function startPollingWatch(roots, regenerate) {
     let lastMtime = latestTreeMtime(roots);
     let timer = null;
@@ -216,13 +428,14 @@ function startPollingWatch(roots, regenerate) {
         if (nextMtime <= lastMtime)
             return;
         lastMtime = nextMtime;
-        clearTimeout(timer);
+        if (timer)
+            clearTimeout(timer);
         timer = setTimeout(() => {
             try {
                 regenerate();
             }
             catch (error) {
-                console.error(`dashboard regeneration failed: ${error.message}`);
+                console.error(`dashboard regeneration failed: ${errorMessage(error)}`);
             }
         }, 250);
     }, 1000);
@@ -306,15 +519,26 @@ function writeJson(response, status, payload) {
     response.end(`${JSON.stringify(payload)}\n`);
 }
 function errorPayload(error) {
-    const payload = { error: error.message };
-    if (error.code)
-        payload.code = error.code;
-    if (Array.isArray(error.recovery) && error.recovery.length > 0)
-        payload.recovery = error.recovery;
-    if (error.details)
-        payload.details = error.details;
+    const source = isRecord(error) ? error : {};
+    const payload = { error: errorMessage(error) };
+    if (source.code)
+        payload.code = source.code;
+    if (Array.isArray(source.recovery) && source.recovery.length > 0)
+        payload.recovery = source.recovery;
+    if (source.details)
+        payload.details = source.details;
     return payload;
 }
+function errorStatus(error, fallback = 400) {
+    const source = isRecord(error) ? error : {};
+    return typeof source.status === "number" ? source.status : fallback;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error || "unknown error");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
 function mimeType(filePath) {
     if (filePath.endsWith(".html"))
         return "text/html; charset=utf-8";

package/dist/lib/dashboard-writer.mjs

@@ -28,6 +28,8 @@ export function writeDashboardDirectory(outDir, bundle, options = {}) {
     writeJsonFile(path.join(target, "data/tables.json"), bundle.tables);
     writeJsonFile(path.join(target, "data/documents.json"), bundle.documents);
     writeJsonFile(path.join(target, "data/graph.json"), bundle.graph);
+    writeJsonFile(path.join(target, "data/modules.json"), bundle.modules || []);
+    writeJsonFile(path.join(target, "data/moduleSummary.json"), bundle.moduleSummary || {});
     writeJsonFile(path.join(target, "data/adoption.json"), bundle.adoption);
     writeJsonFile(path.join(target, "data/presetCatalog.json"), bundle.presetCatalog);
     fs.writeFileSync(path.join(target, "assets/dashboard-data.js"), `window.__HARNESS_DASHBOARD__ = ${JSON.stringify(bundle, null, 2)};\n`);
@@ -150,7 +152,8 @@ function assertSafeDashboardTarget(target, options) {
         const entries = fs.readdirSync(target);
         const hasMarker = fs.existsSync(path.join(target, dashboardMarker));
         const canRecoverGeneratedDashboard = options.recoverGeneratedDashboard === true && looksLikeGeneratedDashboardDirectory(target);
-        if (entries.length > 0 && !hasMarker && !canRecoverGeneratedDashboard) {
+        const canReplaceExistingOutput = options.replaceExistingDashboardOutput === true;
+        if (entries.length > 0 && !hasMarker && !canRecoverGeneratedDashboard && !canReplaceExistingOutput) {
             throw new Error(`Refusing to overwrite non-dashboard directory: ${target}`);
         }
     }

package/dist/lib/git-status-summary.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { inspectGit } from "./governance-sync.mjs";

package/dist/lib/governance-index-generator.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Governance index rendering stays behavior-first until task/governance surface types are modeled.
 import fs from "node:fs";
 import path from "node:path";
@@ -21,9 +20,9 @@ export function rebuildGovernanceIndexes(targetInput, { dryRun = false, archive
         const changes = surfaces.map((surface) => ({
             surface: surface.surface,
             destination: surface.relative,
-            action: surface.archiveOnly
-                ? apply ? "archive-legacy-governance-table" : "would-archive-legacy-governance-table"
-                : apply ? "rebuild-governance-index" : "would-rebuild-governance-index",
+            action: isArchiveOnlySurface(surface)
+                ? effectiveApply ? "archive-legacy-governance-table" : "would-archive-legacy-governance-table"
+                : effectiveApply ? "rebuild-governance-index" : "would-rebuild-governance-index",
             generatedRows: surface.rows.length,
             archive: archive ? `${archiveDir}/${surface.relative}` : "",
         }));
@@ -38,7 +37,7 @@ export function rebuildGovernanceIndexes(targetInput, { dryRun = false, archive
                 fs.copyFileSync(surface.absolute, archivePath);
                 allowed.push(toPosix(path.relative(target.projectRoot, archivePath)));
             }
-            if (surface.archiveOnly) {
+            if (isArchiveOnlySurface(surface)) {
                 if (archive && fs.existsSync(surface.absolute)) {
                     fs.rmSync(surface.absolute);
                     allowed.push(surface.relative);
@@ -56,6 +55,9 @@ export function rebuildGovernanceIndexes(targetInput, { dryRun = false, archive
         releaseGovernanceSync(context);
     }
 }
+function isArchiveOnlySurface(surface) {
+    return "archiveOnly" in surface && surface.archiveOnly === true;
+}
 function governanceSurfaces(target, tasks) {
     return [
         {