coding-agent-harness 1.0.8 → 1.1.0

package/dist/lib/structure-migration.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { normalizeLocale, normalizeTarget, readJsonSafe, toPosix, } from "./core-shared.mjs";
@@ -92,7 +91,7 @@ export function applyStructureMigration(targetInput = ".", { force = false } = {
         fs.writeFileSync(manifestPath, renderHarnessManifest({ locale: plan.capabilities.locale, capabilities: plan.capabilities.names }));
         applied.push({ action: "write-manifest", destination: plan.manifest });
     }
-    for (const action of plan.actions.filter((entry) => entry.action === "move")) {
+    for (const action of plan.actions.filter(isMoveAction)) {
         const source = path.join(targetRoot, action.source);
         const destination = path.join(targetRoot, action.destination);
         if (!fs.existsSync(source))
@@ -150,7 +149,7 @@ function preflightStructureMigration(plan, { force = false } = {}) {
     if (force)
         return;
     const conflicts = [];
-    for (const action of plan.actions.filter((entry) => entry.action === "move")) {
+    for (const action of plan.actions.filter(isMoveAction)) {
         const source = path.join(plan.target, action.source);
         const destination = path.join(plan.target, action.destination);
         if (fs.existsSync(source) && fs.existsSync(destination))
@@ -161,6 +160,9 @@ function preflightStructureMigration(plan, { force = false } = {}) {
         throw new Error(`Refusing to overwrite existing v2 destination(s): ${conflicts.join(", ")}`);
     }
 }
+function isMoveAction(action) {
+    return action.action === "move" && typeof action.source === "string";
+}
 function moduleTaskNormalizationConflicts(targetRoot) {
     const modulesRoot = path.join(targetRoot, legacyPath(legacyModuleRoot));
     if (!fs.existsSync(modulesRoot))
@@ -207,7 +209,7 @@ function readLegacyCapabilities(projectRoot) {
     if (raw) {
         locale = normalizeLocale(raw.locale);
         for (const entry of raw.capabilities || [])
-            names.add(typeof entry === "string" ? entry : entry.name);
+            names.add(typeof entry === "string" ? entry : entry.name || "");
     }
     return { locale, names: [...names].filter(Boolean) };
 }

package/dist/lib/subagent-authorization-audit.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import path from "node:path";
 import { readFileSafe, toPosix, walkFiles, isArchivedHarnessPath, } from "./core-shared.mjs";
 import { firstColumn, splitMarkdownRow, } from "./markdown-utils.mjs";
@@ -80,7 +79,14 @@ function subagentAuthorizationRows(content) {
             .filter((line) => line.trim().startsWith("|"))
             .map(splitMarkdownRow)
             .filter((row) => row.length === header.length)
-            .map((row) => Object.fromEntries(Object.entries(indexes).map(([key, column]) => [key, column >= 0 ? row[column] || "" : ""])));
+            .map((row) => ({
+            role: row[indexes.role] || "",
+            status: row[indexes.status] || "",
+            authorizedBy: indexes.authorizedBy >= 0 ? row[indexes.authorizedBy] || "" : "",
+            authorizedAt: indexes.authorizedAt >= 0 ? row[indexes.authorizedAt] || "" : "",
+            scope: indexes.scope >= 0 ? row[indexes.scope] || "" : "",
+            worktreeBranch: indexes.worktreeBranch >= 0 ? row[indexes.worktreeBranch] || "" : "",
+        }));
     }
     return [];
 }

package/dist/lib/task-archive-eligibility.mjs

@@ -0,0 +1,65 @@
+import { isConcreteAuditField } from "./task-audit-metadata.mjs";
+import { normalizeReviewBoolean } from "./task-review-model.mjs";
+export function assessArchiveEligibility(task, { archivedBy = "", now = new Date().toISOString() } = {}) {
+    const reason = archiveBlockReason(task, { archivedBy });
+    if (reason)
+        return { eligible: false, reason, auditFields: {} };
+    const confirmation = (task.reviewConfirmation || {});
+    const actor = normalizeArchiveActor(archivedBy);
+    return {
+        eligible: true,
+        reason: "",
+        auditFields: {
+            "Archived By": actor,
+            "Archived At": now,
+            "Review Confirmed By": String(confirmation.reviewer || ""),
+            "Review Confirmed At": String(confirmation.confirmedAt || ""),
+            "Review Confirmation ID": String(confirmation.confirmationId || ""),
+            "Review Commit SHA": String(confirmation.commitSha || ""),
+        },
+    };
+}
+export function archiveBlockReason(task, { archivedBy = "" } = {}) {
+    if (task.deletionState === "superseded")
+        return "superseded tasks cannot be archived";
+    if (task.state === "blocked" || (task.taskQueues || []).includes("blocked")) {
+        return "blocked tasks cannot be archived without an explicit human waiver";
+    }
+    const blockingRisks = (task.risks || []).filter((risk) => normalizeReviewBoolean(risk.open) !== "no" && (normalizeReviewBoolean(risk.blocksRelease) === "yes" || ["P0", "P1", "P2"].includes(String(risk.severity))));
+    if (blockingRisks.length)
+        return "tasks with open blocking review findings cannot be archived without an explicit human waiver";
+    if (task.state !== "done")
+        return `state:${task.state || "unknown"}`;
+    if (task.budget !== "simple" && task.closeoutStatus !== "closed")
+        return "tasks must have closed closeout materials before archive";
+    if (task.materialsReady === false && task.reviewStatus !== "confirmed") {
+        return "tasks with incomplete closeout materials cannot be archived without an explicit human waiver";
+    }
+    const confirmation = (task.reviewConfirmation || {});
+    if (confirmation.confirmed !== true)
+        return "Human review confirmation is required before task archive";
+    const missingConfirmationFields = [];
+    if (!isConcreteAuditField(confirmation.confirmationId))
+        missingConfirmationFields.push("Confirmation ID");
+    if (!isConcreteAuditField(confirmation.confirmedAt))
+        missingConfirmationFields.push("Confirmed At");
+    if (!isConcreteAuditField(confirmation.reviewer))
+        missingConfirmationFields.push("Reviewer");
+    if (!isConcreteAuditField(confirmation.commitSha))
+        missingConfirmationFields.push("Review Commit SHA");
+    if (missingConfirmationFields.length) {
+        return `Human review confirmation is not traceable; missing ${missingConfirmationFields.join(", ")}`;
+    }
+    if (!normalizeArchiveActor(archivedBy)) {
+        return "task archive requires --archived-by <name-or-email> for accountability";
+    }
+    return "";
+}
+export function normalizeArchiveActor(value) {
+    const actor = String(value || "").replace(/\r?\n/g, " ").trim();
+    if (!actor)
+        return "";
+    if (/^(coordinator|agent|unknown|n\/a|na|none|pending|todo|tbd)$/i.test(actor))
+        return "";
+    return actor;
+}

package/dist/lib/task-audit-metadata.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Dynamic audit metadata parsing stays behavior-first until the metadata domain model PR.
 import { spawnSync } from "node:child_process";
 import path from "node:path";
@@ -178,22 +177,24 @@ export function taskAuditMaterialIssues(target, taskDir, audit) {
     }));
 }
 export function scaffoldProvenanceSummaryFromTaskAudit(audit) {
-    const fields = audit?.fields || new Map();
+    const parsed = normalizeTaskAuditLike(audit);
+    const fields = parsed.fields;
     return {
         required: true,
-        present: Boolean(audit?.present),
+        present: parsed.present,
         createdBy: normalizeToken(fields.get("created by")),
         command: fields.get("command shape") || "",
         createdAt: fields.get("created at") || "",
         budget: normalizeToken(fields.get("budget")),
         templateSource: fields.get("template source") || "",
         exceptionReason: fields.get("exception reason") || "",
-        issues: audit?.issues || [],
+        issues: parsed.issues,
     };
 }
 export function reviewConfirmationFromTaskAudit(audit, { taskKey = "" } = {}) {
-    const fields = audit?.fields || new Map();
-    if (!audit?.present)
+    const parsed = normalizeTaskAuditLike(audit);
+    const fields = parsed.fields;
+    if (!parsed.present)
         return null;
     const status = normalizeToken(fields.get("human review status"));
     if (status !== "confirmed")
@@ -204,9 +205,8 @@ export function reviewConfirmationFromTaskAudit(audit, { taskKey = "" } = {}) {
     const commitSha = fields.get("review commit sha") || "";
     const auditStatus = fields.get("audit status") || "";
     const auditSource = fields.get("audit source") || "";
-    const migratedLegacy = auditSource === "migrated-legacy-review";
-    const confirmTextMismatch = Boolean(!migratedLegacy && taskKey && isConcreteAuditField(confirmText) && !taskKeysMatch(confirmText, taskKey));
-    const commitShaInvalid = Boolean(!migratedLegacy && isConcreteAuditField(commitSha) && !/^[0-9a-f]{7,40}$/i.test(commitSha));
+    const confirmTextMismatch = Boolean(taskKey && isConcreteAuditField(confirmText) && !taskKeysMatch(confirmText, taskKey));
+    const commitShaInvalid = Boolean(isConcreteAuditField(commitSha) && !/^[0-9a-f]{7,40}$/i.test(commitSha));
     const auditStatusInvalid = Boolean(isConcreteAuditField(auditStatus) && auditStatus.trim().toLowerCase() !== "committed");
     const invalidFields = [
         ...(confirmTextMismatch ? ["Confirm Text match"] : []),
@@ -231,7 +231,7 @@ export function reviewConfirmationFromTaskAudit(audit, { taskKey = "" } = {}) {
         auditStatusInvalid,
         auditSource,
         migratedFrom: fields.get("migrated from") || "",
-        gitAudit: migratedLegacy ? { valid: true, migrated: true } : null,
+        gitAudit: null,
         gitAuditInvalid: false,
     };
 }
@@ -250,7 +250,7 @@ export function extractLegacyBlock(content, pattern) {
 }
 export function fieldsFromMarkdownBlock(block) {
     const fields = new Map();
-    const tableRows = markdownTableRows(block);
+    const tableRows = markdownTableRows(String(block || ""));
     const header = tableRows[0] || [];
     const fieldIndex = firstColumn(header, ["Field", "字段"]);
     const valueIndex = firstColumn(header, ["Value", "值"]);
@@ -374,3 +374,17 @@ function isValidDateOnly(value) {
     const date = new Date(`${raw}T00:00:00.000Z`);
     return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === raw;
 }
+function normalizeTaskAuditLike(audit) {
+    if (!audit || typeof audit !== "object") {
+        return { present: false, fields: new Map(), issues: [], summary: taskAuditSummary(new Map(), []) };
+    }
+    const record = audit;
+    const fields = record.fields instanceof Map ? record.fields : new Map();
+    const issues = Array.isArray(record.issues) ? record.issues : [];
+    return {
+        present: Boolean(record.present),
+        fields,
+        issues,
+        summary: record.summary || taskAuditSummary(fields, issues),
+    };
+}

package/dist/lib/task-audit-migration.mjs

@@ -1,10 +1,19 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { normalizeTarget, readFileSafe, toPosix } from "./core-shared.mjs";
 import { listTaskPlanPaths, taskIdForDirectory } from "./task-scanner.mjs";
 import { extractLegacyBlock, fieldsFromMarkdownBlock, humanReviewConfirmationHeadingPattern, isConcreteAuditField, legacyExtraFieldsJson, parseTaskAuditMetadata, replaceTaskAuditMetadata, scaffoldProvenanceHeadingPattern, stripLegacyAuditBlocks, taskAuditFieldOrder, } from "./task-audit-metadata.mjs";
 import { firstColumn, markdownTableRows } from "./markdown-utils.mjs";
+class TaskAuditMigrationError extends Error {
+    plan;
+    cause;
+    constructor(message, { plan, cause } = {}) {
+        super(message);
+        this.name = "TaskAuditMigrationError";
+        this.plan = plan;
+        this.cause = cause;
+    }
+}
 const scaffoldFieldMap = new Map([
     ["created by", "Created By"],
     ["command", "Command Shape"],
@@ -77,9 +86,7 @@ export function applyTaskAuditIndexMigration(targetInput) {
     const target = normalizeTarget(targetInput);
     const plan = planTaskAuditIndexMigration(targetInput);
     if (plan.failures.length) {
-        const error = new Error(`Task audit INDEX migration failed during plan: ${plan.failures.map((failure) => `${failure.taskId}: ${failure.failure}`).join("; ")}`);
-        error.plan = plan;
-        throw error;
+        throw new TaskAuditMigrationError(`Task audit INDEX migration failed during plan: ${plan.failures.map((failure) => `${failure.taskId}: ${failure.failure}`).join("; ")}`, { plan });
     }
     const writes = [];
     for (const action of plan.actions) {
@@ -114,10 +121,7 @@ export function applyTaskAuditIndexMigration(targetInput) {
             fs.writeFileSync(write.briefPath, write.before.briefContent);
             fs.writeFileSync(write.reviewPath, write.before.reviewContent);
         }
-        const error = new Error(`Task audit INDEX migration apply failed and was rolled back: ${cause.message}`);
-        error.cause = cause;
-        error.plan = plan;
-        throw error;
+        throw new TaskAuditMigrationError(`Task audit INDEX migration apply failed and was rolled back: ${errorMessage(cause)}`, { cause, plan });
     }
     return { ...plan, result: "applied" };
 }
@@ -146,7 +150,7 @@ function parseLegacyAudit({ taskId, indexContent, scaffoldBlock, reviewBlock })
         for (const [legacyKey, canonical] of scaffoldFieldMap) {
             const value = scaffold.get(legacyKey);
             if (isConcreteAuditField(value))
-                fields[canonical] = value;
+                fields[canonical] = value || "";
         }
         for (const field of requiredScaffold) {
             if (!isConcreteAuditField(fields[field]))
@@ -169,7 +173,7 @@ function parseLegacyAudit({ taskId, indexContent, scaffoldBlock, reviewBlock })
             for (const [legacyKey, canonical] of reviewFieldMap) {
                 const value = review.get(legacyKey);
                 if (isConcreteAuditField(value))
-                    fields[canonical] = value;
+                    fields[canonical] = value || "";
             }
             const legacyTaskKey = review.get("task key") || "";
             if (isConcreteAuditField(legacyTaskKey) && legacyTaskKey !== taskId && !taskId.endsWith(`/${legacyTaskKey}`))
@@ -212,8 +216,8 @@ function parseLegacyAudit({ taskId, indexContent, scaffoldBlock, reviewBlock })
         }
     }
     if (extraEntries.length) {
-        const mergedExtra = mergeLegacyExtraFields(fields["Legacy Extra Fields"], extraEntries);
-        if (mergedExtra.failure)
+        const mergedExtra = mergeLegacyExtraFields(fields["Legacy Extra Fields"] || "", extraEntries);
+        if (mergedExtra.failure !== undefined)
             failures.push(mergedExtra.failure);
         else
             fields["Legacy Extra Fields"] = mergedExtra.json;
@@ -291,7 +295,7 @@ function normalizeExistingAuditFields(fields, taskId, extraEntries) {
 }
 function replacePreserving(fields, extraEntries, field, replacement) {
     if (isConcreteAuditField(fields[field]))
-        extraEntries.push([`Original ${field}`, fields[field]]);
+        extraEntries.push([`Original ${field}`, fields[field] || ""]);
     fields[field] = replacement;
 }
 function parseLegacyReviewFields(body) {
@@ -333,7 +337,7 @@ function concreteReviewConfirmationValues(fields) {
         "commit sha",
         "review commit sha",
     ];
-    return confirmationKeys.map((key) => fields.get(key)).filter(isConcreteAuditField);
+    return confirmationKeys.map((key) => fields.get(key)).filter((value) => isConcreteAuditField(value));
 }
 function titleField(value) {
     return String(value || "")
@@ -353,3 +357,6 @@ function isValidDateOnly(value) {
     const date = new Date(`${raw}T00:00:00.000Z`);
     return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === raw;
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/task-discovery-contract.mjs

@@ -0,0 +1,32 @@
+import path from "node:path";
+import fs from "node:fs";
+import { toPosix } from "./core-shared.mjs";
+export function isExcludedTaskPlanPath(file, harnessPaths) {
+    const relative = toPosix(path.relative(harnessPaths.projectRoot, file));
+    const segments = relative.split("/").filter(Boolean);
+    if (segments.includes("_task-template") || segments.includes("_optional-structures"))
+        return true;
+    if (isTaskLocalOptionalStructure(file, harnessPaths.projectRoot, segments))
+        return true;
+    const generatedRoot = toPosix(path.relative(harnessPaths.projectRoot, harnessPaths.generatedRoot || ""));
+    if (generatedRoot && (relative === `${generatedRoot}/task_plan.md` || relative.startsWith(`${generatedRoot}/`)))
+        return true;
+    const governanceRoot = toPosix(path.relative(harnessPaths.projectRoot, harnessPaths.governanceRoot || ""));
+    return Boolean(governanceRoot && (relative.startsWith(`${governanceRoot}/releases/`) ||
+        relative.startsWith(`${governanceRoot}/archive/`) ||
+        relative.startsWith(`${governanceRoot}/generated/`)));
+}
+function isTaskLocalOptionalStructure(file, projectRoot, segments) {
+    const taskPlanFile = path.basename(file) === "task_plan.md";
+    if (!taskPlanFile)
+        return false;
+    for (const segmentName of ["artifacts", "references"]) {
+        const segmentIndex = segments.indexOf(segmentName);
+        if (segmentIndex < 1)
+            continue;
+        const ancestorDir = path.join(projectRoot, ...segments.slice(0, segmentIndex));
+        if (fs.existsSync(path.join(ancestorDir, "task_plan.md")))
+            return true;
+    }
+    return false;
+}

package/dist/lib/task-index.mjs

@@ -1,13 +1,13 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
 import { normalizeTarget, readFileSafe, toPosix, } from "./core-shared.mjs";
 import { collectTasks } from "./task-scanner.mjs";
 import { taskScannerVersion } from "./task-review-model.mjs";
+const collectTasksForIndex = collectTasks;
 export function buildTaskIndex(targetInput) {
     const target = normalizeTarget(targetInput);
-    const tasks = collectTasks(target);
+    const tasks = collectTasksForIndex(target);
     assertUniqueTaskKeys(tasks);
     return {
         schemaVersion: target.harness.version === 2 ? "task-index/v2" : "task-index/v1",
@@ -56,6 +56,7 @@ export function buildTaskIndex(targetInput) {
             supersedes: task.supersedes || [],
             supersededBy: task.supersededBy || "",
             deletionState: task.deletionState || "active",
+            deleteReason: task.deleteReason || "",
             archiveMetadata: task.archiveMetadata || {},
             hiddenByDefault: task.hiddenByDefault === true,
             repairPrompt: task.repairPrompt || "",

package/dist/lib/task-lesson-candidates.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { tableAfterHeading, firstColumn, } from "./markdown-utils.mjs";
@@ -85,7 +84,7 @@ export function parseLessonCandidateStatus(content) {
 export function isLessonCandidateDecisionComplete(candidateStatus) {
     if (!candidateStatus || candidateStatus.issues?.length)
         return false;
-    return reviewCompleteLessonCandidateStatuses.has(candidateStatus.status);
+    return reviewCompleteLessonCandidateStatuses.has(String(candidateStatus.status || ""));
 }
 export function validateLessonCandidateDetailArtifacts(target, taskDir, candidateStatus) {
     const issues = [];