coding-agent-harness 1.0.4 → 1.0.5

package/scripts/lib/dashboard-data.mjs

@@ -1,8 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import {
+  legacyChecker,
   repoRoot,
+  builtinPresetRoot,
   normalizeTarget,
+  projectPresetRoot,
   readFileSafe,
   sanitizeText,
   sanitizeDeep,
@@ -15,24 +19,29 @@ import {
   legacyVisualRoadmapFile,
   lessonCandidatesFile,
   longRunningTaskContractFile,
+  userPresetRoot,
 } from "./core-shared.mjs";
 import {
   parseAllMarkdownTables,
   getCell,
   splitDependencies,
 } from "./markdown-utils.mjs";
-import { readCapabilityRegistry } from "./capability-registry.mjs";
-import { buildStatus } from "./check-profiles.mjs";
+import { readCapabilityRegistry, validateCapabilities } from "./capability-registry.mjs";
+import { buildStatusData } from "./status-builder.mjs";
 import {
   listTaskPlanPaths,
   parseTaskState,
   isActiveTaskState,
 } from "./task-scanner.mjs";
 import { writeDashboardDirectory, writeDashboardFile } from "./dashboard-writer.mjs";
+import { listPresetPackageLayers } from "./preset-registry.mjs";
+import { validateGovernanceTableBoundaries } from "./governance-table-boundary.mjs";
+import { summarizeGitState } from "./git-status-summary.mjs";
 
-export function collectMarkdownDocuments(target) {
-  const docs = collectDashboardDocumentPaths(target);
-  return docs.map((file, index) => {
+export function collectMarkdownDocuments(target, options = {}) {
+  const docs = collectDashboardDocumentPaths(target, options);
+  return docs.map((entry, index) => {
+    const file = typeof entry === "string" ? entry : entry.file;
     const content = sanitizeText(readFileSafe(file));
     const source = prefixedPath(target, file);
     return {
@@ -41,12 +50,14 @@ export function collectMarkdownDocuments(target) {
       title: titleFromMarkdown(content, path.basename(file)),
       type: documentKind(source),
       content,
+      ...(entry.partial ? { partial: true, partialReason: entry.partialReason || "partial", taskId: entry.taskId || "" } : {}),
     };
   });
 }
 
-function collectDashboardDocumentPaths(target) {
+function collectDashboardDocumentPaths(target, options = {}) {
   const selected = new Set();
+  const partial = new Map();
   const addDocsPath = (relativePath) => {
     const file = path.join(target.docsRoot, relativePath);
     if (fs.existsSync(file)) selected.add(file);
@@ -66,21 +77,38 @@ function collectDashboardDocumentPaths(target) {
     if (path.basename(file).startsWith("_")) continue;
     selected.add(file);
   }
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
+  const tasksByPlanPath = new Map((options.tasks || []).map((task) => [
+    path.join(target.projectRoot, String(task.taskPlanPath || "").replace(/^TARGET:/, "")),
+    task,
+  ]));
+  for (const taskPlanPath of options.taskPlanPaths || listTaskPlanPaths(target)) {
     const taskDir = path.dirname(taskPlanPath);
     const progress = readFileSafe(path.join(taskDir, "progress.md"));
     const state = parseTaskState(progress);
     const active = isActiveTaskState(state);
-    const documentNames = active
-      ? ["brief.md", "task_plan.md", "execution_strategy.md", visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, "progress.md", "review.md", "findings.md"]
+    const task = tasksByPlanPath.get(taskPlanPath);
+    const historicalClosed = !active && task?.closeoutStatus === "closed";
+    const documentNames = historicalClosed
+      ? ["brief.md"]
       : ["brief.md", "task_plan.md", "execution_strategy.md", visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, "progress.md", "review.md", "findings.md"];
     for (const fileName of documentNames) {
       const file = path.join(taskDir, fileName);
-      if (fs.existsSync(file)) selected.add(file);
+      if (fs.existsSync(file)) {
+        selected.add(file);
+        if (historicalClosed) {
+          partial.set(file, {
+            partial: true,
+            partialReason: "historical-closed",
+            taskId: task?.id || path.basename(taskDir),
+          });
+        }
+      }
     }
-    for (const indexFile of ["references/INDEX.md", "artifacts/INDEX.md"]) {
-      const file = path.join(taskDir, indexFile);
-      if (fs.existsSync(file)) selected.add(file);
+    if (!historicalClosed) {
+      for (const indexFile of ["references/INDEX.md", "artifacts/INDEX.md"]) {
+        const file = path.join(taskDir, indexFile);
+        if (fs.existsSync(file)) selected.add(file);
+      }
     }
   }
   for (const file of walkFiles(path.join(target.docsRoot, "09-PLANNING/MODULES"))) {
@@ -94,7 +122,8 @@ function collectDashboardDocumentPaths(target) {
     .filter((file) => !file.includes(`${path.sep}_archive${path.sep}`))
     .filter((file) => !file.includes(`${path.sep}_task-template${path.sep}`))
     .filter((file) => !file.includes(`${path.sep}_optional-structures${path.sep}`))
-    .sort();
+    .sort()
+    .map((file) => ({ file, ...(partial.get(file) || {}) }));
 }
 
 function documentKind(source) {
@@ -145,7 +174,17 @@ export function collectGraph(status, tables = { tables: [] }) {
     addNode({ id: `task:${task.id}`, type: "task", label: task.title, state: task.state, completion: task.completion });
     for (const phase of task.phases || []) {
       const phaseId = `phase:${task.id}:${phase.id}`;
-      addNode({ id: phaseId, type: "phase", label: phase.id, state: phase.state, completion: phase.completion, taskId: task.id });
+      addNode({
+        id: phaseId,
+        type: "phase",
+        label: phase.id,
+        state: phase.state,
+        completion: phase.completion,
+        kind: phase.kind,
+        actor: phase.actor,
+        exitCommand: phase.exitCommand,
+        taskId: task.id,
+      });
       addEdge({ from: `task:${task.id}`, to: phaseId, type: "contains" });
       for (const dependency of phase.dependsOn || []) {
         addEdge({ from: `phase:${task.id}:${dependency}`, to: phaseId, type: "depends_on" });
@@ -386,13 +425,82 @@ function warningAction(message) {
 }
 
 export function buildDashboardBundle(targetInput, options = {}) {
-  const status = buildStatus(targetInput, options);
   const target = normalizeTarget(targetInput);
-  const documents = { documents: collectMarkdownDocuments(target) };
+  const taskPlanPaths = listTaskPlanPaths(target);
+  const capabilityState = validateCapabilities(target);
+  const gitState = summarizeGitState(target);
+  const declaredCapabilities = new Set(capabilityState.registry.capabilities.map((capability) => capability.name));
+  const shouldRunLegacy = !options.skipLegacyCheck && (capabilityState.registry.mode === "legacy-compat" || declaredCapabilities.has("safe-adoption"));
+  const legacy = shouldRunLegacy ? runDashboardLegacyCheck(target) : { status: "skipped", code: 0, stdout: "", stderr: "" };
+  const legacyWarnings = legacy.status === "fail" ? [`adoption-needed: legacy check failed: ${(legacy.stderr || legacy.stdout).trim()}`] : [];
+  const governanceBoundaries = validateGovernanceTableBoundaries(target);
+  const status = buildStatusData(target, {
+    ...options,
+    capabilityState,
+    gitState,
+    taskPlanPaths,
+    legacy,
+    failures: [...capabilityState.failures, ...governanceBoundaries.failures],
+    warnings: [...capabilityState.warnings, ...legacyWarnings, ...governanceBoundaries.warnings, ...gitState.warnings],
+  });
+  const documents = { documents: collectMarkdownDocuments(target, { taskPlanPaths, tasks: status.tasks }) };
   const tables = collectTables(documents.documents);
   const graph = collectGraph(status, tables);
   const adoption = collectAdoption(status);
-  return sanitizeDeep({ status, tables, documents, graph, adoption });
+  const presetCatalog = collectPresetCatalog(targetInput, target, options);
+  return sanitizeDeep({ status, tables, documents, graph, adoption, presetCatalog });
+}
+
+function runDashboardLegacyCheck(target) {
+  const checkTarget = target.docsOnly ? target.projectRoot : target.input;
+  const result = spawnSync(process.execPath, [legacyChecker, checkTarget], {
+    cwd: repoRoot,
+    encoding: "utf8",
+  });
+  return {
+    status: result.status === 0 ? "pass" : "fail",
+    code: result.status ?? 1,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}
+
+export function collectPresetCatalog(targetInput, target = normalizeTarget(targetInput), options = {}) {
+  const home = options.home || "";
+  const presets = listPresetPackageLayers({ targetInput: target.projectRoot, home }).map((preset) => ({
+    key: `${preset.source}:${preset.id}`,
+    id: preset.id,
+    version: preset.version,
+    source: preset.source,
+    effective: preset.effective === true,
+    purpose: preset.purpose,
+    compatibleBudgets: preset.compatibleBudgets,
+    manifestPath: preset.manifestRelativePath,
+    manifestSha256: preset.manifestSha256,
+    taskKind: preset.task?.kind || "",
+    inputCount: Object.keys(preset.inputs || {}).length,
+    referenceCount: Object.keys(preset.resources?.references || {}).length,
+    artifactCount: Object.keys(preset.resources?.artifacts || {}).length,
+    writeScopeCount: Object.keys(preset.writeScopes || {}).length,
+    evidenceFileCount: Object.keys(preset.evidence?.files || {}).length,
+    requiredReadCount: Array.isArray(preset.context?.requiredReads) ? preset.context.requiredReads.length : 0,
+    checkStatus: "unknown",
+  }));
+  const countSource = (source) => presets.filter((preset) => preset.source === source).length;
+  return {
+    summary: {
+      total: presets.length,
+      project: countSource("project"),
+      user: countSource("user"),
+      builtin: countSource("builtin"),
+    },
+    roots: [
+      { source: "project", path: projectPresetRoot(target.projectRoot) },
+      { source: "user", path: home ? path.join(path.resolve(home), ".coding-agent-harness/presets") : userPresetRoot },
+      { source: "builtin", path: builtinPresetRoot },
+    ],
+    presets,
+  };
 }
 
 export function writeDashboardFolder(outDir, targetInput, options = {}) {

package/scripts/lib/dashboard-workbench.mjs

@@ -9,6 +9,13 @@ import { createLessonSedimentationTask } from "./task-lesson-sedimentation.mjs";
 import { normalizeTarget } from "./core-shared.mjs";
 import { collectTasks } from "./task-scanner.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" };
 
@@ -36,7 +43,7 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
         writeJson(response, 200, {
           mode: "workbench",
           csrfToken,
-          writableActions: ["review-complete", "lesson-sedimentation-task"],
+          writableActions: ["review-complete", "lesson-sedimentation-task", "preset-check", "preset-install", "preset-seed", "preset-uninstall"],
           target: target.projectRoot,
           autoRefresh: autoRefresh === true,
           snapshotVersion,
@@ -94,6 +101,72 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
         return;
       }
 
+      if (requestUrl.pathname === "/api/presets/check" && request.method === "POST") {
+        assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+        const body = await readJsonBody(request);
+        const id = String(body.id || "");
+        if (!id) {
+          writeJson(response, 400, { error: "Missing preset id" });
+          return;
+        }
+        const result = checkPresetPackage(id, { targetInput: target.projectRoot });
+        writeJson(response, 200, result);
+        return;
+      }
+
+      if (requestUrl.pathname === "/api/presets/install" && request.method === "POST") {
+        assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+        const body = await readJsonBody(request);
+        const source = String(body.source || "");
+        if (!source) {
+          writeJson(response, 400, { error: "Missing preset source" });
+          return;
+        }
+        if (/^https?:\/\//i.test(source)) {
+          writeJson(response, 400, { error: "Network preset sources are not supported by the dashboard workbench." });
+          return;
+        }
+        const scope = normalizePresetScope(body.scope);
+        const result = installPresetPackage(source, { force: body.force === true, scope, targetInput: target.projectRoot });
+        regenerate();
+        writeJson(response, 200, { ...result, scope });
+        return;
+      }
+
+      if (requestUrl.pathname === "/api/presets/seed" && request.method === "POST") {
+        assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+        const body = await readJsonBody(request);
+        const scope = normalizePresetScope(body.scope);
+        const result = seedBundledPresets({ force: body.force === true, dryRun: body.dryRun === true, scope, targetInput: target.projectRoot });
+        if (body.dryRun !== true) regenerate();
+        writeJson(response, 200, result);
+        return;
+      }
+
+      if (requestUrl.pathname === "/api/presets/uninstall" && request.method === "POST") {
+        assertTrustedWorkbenchRequest(request, { origin, csrfToken });
+        const body = await readJsonBody(request);
+        const id = String(body.id || "");
+        if (!id) {
+          writeJson(response, 400, { error: "Missing preset id" });
+          return;
+        }
+        if (String(body.confirmText || "").trim() !== id) {
+          writeJson(response, 400, { error: "Preset uninstall requires typing the preset id." });
+          return;
+        }
+        const scope = normalizePresetScope(body.scope);
+        const discovered = listPresetPackages({ targetInput: target.projectRoot }).find((preset) => preset.id === id);
+        if (discovered?.source === "builtin") {
+          writeJson(response, 409, { error: "Builtin preset cannot be uninstalled from the dashboard workbench.", id, source: "builtin" });
+          return;
+        }
+        const result = uninstallPresetPackage(id, { scope, targetInput: target.projectRoot });
+        regenerate();
+        writeJson(response, 200, { ...result, scope });
+        return;
+      }
+
       if (request.method !== "GET" && request.method !== "HEAD") {
         writeJson(response, 405, { error: "Method not allowed" });
         return;
@@ -126,6 +199,12 @@ export async function serveDashboardWorkbench(outDir, targetInput, { host = "127
   await new Promise(() => {});
 }
 
+function normalizePresetScope(value) {
+  const scope = String(value || "project");
+  if (scope !== "project" && scope !== "user") throw new Error(`Invalid preset scope: ${scope}`);
+  return scope;
+}
+
 function isTaskInReviewQueue(task) {
   return task?.reviewQueueState === "ready-to-confirm" && Array.isArray(task?.taskQueues) && task.taskQueues.includes("review");
 }

package/scripts/lib/dashboard-writer.mjs

@@ -1,7 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readJsonSafe } from "./core-shared.mjs";
 
-const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../..");
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "../..");
 const dashboardTemplateRoot = path.join(repoRoot, "templates/dashboard");
 const dashboardMarker = ".harness-dashboard";
 
@@ -28,6 +31,7 @@ export function writeDashboardDirectory(outDir, bundle, options = {}) {
   writeJsonFile(path.join(target, "data/documents.json"), bundle.documents);
   writeJsonFile(path.join(target, "data/graph.json"), bundle.graph);
   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`,
@@ -114,7 +118,7 @@ function renderDashboardIndex(locale = "en-US", options = {}) {
 function readDashboardApp(templateRoot) {
   const manifestPath = path.join(templateRoot, "assets/app.manifest.json");
   if (!fs.existsSync(manifestPath)) return fs.readFileSync(path.join(templateRoot, "assets/app.js"), "utf8");
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const manifest = readJsonSafe(manifestPath, null);
   if (!Array.isArray(manifest) || manifest.length === 0) throw new Error(`Invalid dashboard app manifest: ${manifestPath}`);
   return `${manifest.map((relativePath) => {
     const source = path.join(templateRoot, "assets", relativePath);

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

@@ -27,7 +27,7 @@ export function summarizeGitState(target) {
   const dirty = entries.length > 0;
   const warnings = [];
   if (dirty) {
-    warnings.push(`dirty-state: ${entries.length} uncommitted Git path(s) will block CLI-owned auto-commit; commit them or record owner/no-commit reason before lifecycle commands.`);
+    warnings.push(`dirty-state: ${entries.length} uncommitted Git path(s) may block CLI-owned auto-commit when they overlap a command write scope or are staged; commit them or record owner/no-commit reason before lifecycle commands.`);
   }
   return {
     summary: {