@aipper/aiws 0.0.24 → 0.0.26

package/src/commands/change-evidence-command.js

@@ -0,0 +1,242 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import {
+  buildDeliverySummary,
+  collectCollaborationArtifacts,
+  findLatestFileByMtime,
+  formatDeclaredValues,
+  mergeDeclaredValues,
+  relFromRoot,
+  upsertIdLine,
+  upsertProposalEvidencePath,
+} from "./change-evidence.js";
+import { TMP_REVIEW_FALLBACKS, tmpReviewFallbackPath } from "./change-review-gates.js";
+
+/**
+ * @param {{
+ *   gitRoot: string,
+ *   changeId: string,
+ *   changeDir: string,
+ *   proposalText: string,
+ *   options: { noValidate: boolean, allowFail: boolean }
+ * }} input
+ * @param {{
+ *   appendMetricsEvent: (gitRoot: string, changeId: string, type: string, payload: any) => Promise<void>,
+ *   computeChangeStatus: (gitRoot: string, changeId: string) => Promise<any>,
+ *   currentBranch: (gitRoot: string) => Promise<string>,
+ *   ensureDir: (path: string) => Promise<void>,
+ *   extractId: (label: string, text: string) => string,
+ *   nowIsoUtc: () => string,
+ *   nowStampUtc: () => string,
+ *   pathExists: (path: string) => Promise<boolean>,
+ *   planVerifyHint: (changeId: string) => string,
+ *   readText: (path: string) => Promise<string>,
+ *   splitDeclaredValues: (s: string) => string[],
+ *   validateChangeArtifacts: (gitRoot: string, changeId: string, options: any) => Promise<any>,
+ *   writeText: (path: string, content: string) => Promise<void>,
+ *   UserError: typeof import("../errors.js").UserError
+ * }} deps
+ */
+export async function runChangeEvidenceWorkflow(input, deps) {
+  const { gitRoot, changeId, changeDir, proposalText, options } = input;
+  const planDecl = deps.extractId("Plan_File", proposalText) || deps.extractId("Plan file", proposalText);
+  const planFiles = deps.splitDeclaredValues(planDecl).map((item) => String(item || "").replace(/^\.\//, ""));
+  const planRel = planFiles.length === 1 ? planFiles[0] : "";
+  const planAbs = planRel ? path.join(gitRoot, planRel) : "";
+  const planText = planAbs && (await deps.pathExists(planAbs)) ? await deps.readText(planAbs) : "";
+
+  const now = deps.nowStampUtc();
+  const evidenceDir = path.join(changeDir, "evidence");
+  const reviewDir = path.join(changeDir, "review");
+  const analysisDir = path.join(changeDir, "analysis");
+  const patchesDir = path.join(changeDir, "patches");
+  await deps.ensureDir(evidenceDir);
+  await deps.ensureDir(reviewDir);
+  await deps.ensureDir(analysisDir);
+  await deps.ensureDir(patchesDir);
+
+  /** @type {string[]} */
+  const created = [];
+  const branch = await deps.currentBranch(gitRoot);
+  const status = await deps.computeChangeStatus(gitRoot, changeId);
+
+  const statusPath = path.join(evidenceDir, `change-status-${now}.json`);
+  await deps.writeText(
+    statusPath,
+    JSON.stringify(
+      {
+        generated_at: deps.nowIsoUtc(),
+        ws_root: gitRoot,
+        change_id: changeId,
+        branch: branch || "",
+        phase: status.phase,
+        tasks: status.tasks,
+        bindings: status.bindings,
+        truth: {
+          baseline: { label: status.baselineLabel, at: status.baselineAt },
+          drift_files: status.driftFiles,
+        },
+        evidence: status.evidence?.counts || null,
+        collaboration: status.collaboration?.counts || null,
+        note: "aiws change evidence status snapshot; does not contain secrets.",
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+  created.push(relFromRoot(gitRoot, statusPath));
+
+  /** @type {any | null} */
+  let validateRes = null;
+  let validateFailed = false;
+  let validatePathForError = "";
+  if (!options.noValidate) {
+    validateRes = await deps.validateChangeArtifacts(gitRoot, changeId, { strict: true, allowTruthDrift: false });
+    const validatePath = path.join(evidenceDir, `change-validate-strict-${now}.json`);
+    await deps.writeText(validatePath, JSON.stringify(validateRes, null, 2) + "\n");
+    created.push(relFromRoot(gitRoot, validatePath));
+    validateFailed = validateRes.ok !== true;
+    validatePathForError = validatePath;
+  }
+
+  const validateStampDir = path.join(gitRoot, ".agentdocs", "tmp", "aiws-validate");
+  const latestValidateStamp = await findLatestFileByMtime(validateStampDir, (name) => name.endsWith(".json"));
+  if (latestValidateStamp) {
+    const dest = path.join(evidenceDir, `aiws-validate-stamp-${now}.json`);
+    await fs.copyFile(latestValidateStamp, dest);
+    created.push(relFromRoot(gitRoot, dest));
+  }
+
+  const syncStampDir = path.join(gitRoot, ".agentdocs", "tmp", "change-sync");
+  const latestSyncStamp = await findLatestFileByMtime(syncStampDir, (name) => name.endsWith(`-${changeId}.json`));
+  if (latestSyncStamp) {
+    const dest = path.join(evidenceDir, `change-sync-stamp-${now}.json`);
+    await fs.copyFile(latestSyncStamp, dest);
+    created.push(relFromRoot(gitRoot, dest));
+  }
+
+  for (const { fileName, persistentKind } of TMP_REVIEW_FALLBACKS) {
+    const src = tmpReviewFallbackPath(gitRoot, fileName);
+    if (!(await deps.pathExists(src))) continue;
+    const dest = persistentKind === "evidence" ? path.join(evidenceDir, fileName) : path.join(reviewDir, fileName);
+    if (!(await deps.pathExists(dest))) {
+      await fs.copyFile(src, dest);
+    }
+    const rel = relFromRoot(gitRoot, dest);
+    if (!created.includes(rel)) created.push(rel);
+  }
+
+  if (await deps.pathExists(reviewDir)) {
+    try {
+      const reviewEntries = await fs.readdir(reviewDir, { withFileTypes: true });
+      for (const entry of reviewEntries) {
+        if (!entry.isFile()) continue;
+        if (entry.name === "codex-review.md") continue;
+        if (!entry.name.endsWith(".md")) continue;
+        const rel = relFromRoot(gitRoot, path.join(reviewDir, entry.name));
+        if (!created.includes(rel)) created.push(rel);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  const collaboration = await collectCollaborationArtifacts(gitRoot, changeDir);
+  const collaborationPath = path.join(evidenceDir, `collaboration-summary-${now}.json`);
+  await deps.writeText(
+    collaborationPath,
+    JSON.stringify(
+      {
+        generated_at: deps.nowIsoUtc(),
+        ws_root: gitRoot,
+        change_id: changeId,
+        counts: collaboration.counts,
+        dirs: collaboration.dirs,
+        note: "aiws collaboration summary; patch files are drafts and must be reviewed before apply.",
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+  created.push(relFromRoot(gitRoot, collaborationPath));
+
+  const summaryAbs = path.join(evidenceDir, `delivery-summary-${now}.md`);
+  await deps.writeText(
+    summaryAbs,
+    buildDeliverySummary({
+      gitRoot,
+      changeId,
+      branch: branch || "",
+      status,
+      collaboration,
+      created,
+      validateRes,
+      validateFailed,
+    }),
+  );
+  created.push(relFromRoot(gitRoot, summaryAbs));
+
+  const declaredEvidence = deps.extractId("Evidence_Path", proposalText) || deps.extractId("Evidence_Path(s)", proposalText);
+  const existingProposalEvidence = deps.splitDeclaredValues(declaredEvidence).map((item) => String(item || "").replace(/^\.\//, ""));
+  const mergedEvidence = mergeDeclaredValues(existingProposalEvidence, created);
+  const mergedEvidenceText = formatDeclaredValues(mergedEvidence);
+
+  const updatedProposal = upsertProposalEvidencePath(proposalText, mergedEvidenceText);
+  if (updatedProposal.changed) {
+    await deps.writeText(path.join(changeDir, "proposal.md"), updatedProposal.text);
+  }
+
+  let planUpdated = false;
+  if (planAbs && planText) {
+    const existingPlanEvidence = deps
+      .splitDeclaredValues(deps.extractId("Evidence_Path", planText) || deps.extractId("Evidence_Path(s)", planText))
+      .map((item) => String(item || "").replace(/^\.\//, ""));
+    const mergedPlanEvidence = mergeDeclaredValues(existingPlanEvidence, mergedEvidence);
+    const mergedPlanEvidenceText = formatDeclaredValues(mergedPlanEvidence);
+    const updatedPlan = upsertIdLine(planText, ["Evidence_Path", "Evidence_Path(s)"], mergedPlanEvidenceText, { insertAfterLabels: ["Plan_File", "Contract_Row"] });
+    if (updatedPlan.changed) {
+      await deps.writeText(planAbs, updatedPlan.text);
+      planUpdated = true;
+    }
+  }
+
+  await deps.appendMetricsEvent(gitRoot, changeId, "evidence", {
+    generated_at: deps.nowIsoUtc(),
+    created: created.length,
+    strict_validate: options.noValidate ? "skipped" : validateRes && validateRes.ok === true ? "ok" : "failed",
+    allow_fail: options.allowFail === true,
+  });
+
+  /** @type {string[]} */
+  const outputLines = [];
+  outputLines.push(`✓ aiws change evidence: ${changeId}`);
+  outputLines.push(`dir: ${path.relative(gitRoot, changeDir)}`);
+  if (planRel) outputLines.push(`Plan_File: ${planRel}`);
+  outputLines.push("created:");
+  if (created.length > 0) {
+    for (const item of created) outputLines.push(`- ${item}`);
+  } else {
+    outputLines.push("- (none)");
+  }
+  outputLines.push("updated:");
+  outputLines.push(`- ${path.relative(gitRoot, path.join(changeDir, "proposal.md"))} (Evidence_Path)`);
+  if (planRel && planText && planUpdated) outputLines.push(`- ${planRel} (Evidence_Path)`);
+  else if (planRel && planText) outputLines.push(`- ${planRel} (Evidence_Path)`);
+  outputLines.push("");
+  outputLines.push("next:");
+  outputLines.push(`- ${deps.planVerifyHint(changeId)}`);
+  if (validateFailed) outputLines.push("- fix validation errors, then re-run evidence (or run with --allow-fail to proceed)");
+  else outputLines.push(`- verify evidence gate: \`aiws change validate ${changeId} --strict --check-evidence\``);
+
+  let errorToThrow = null;
+  if (validateFailed && !options.allowFail) {
+    const details = (validateRes && validateRes.raw ? String(validateRes.raw) : "").trim() || "Validation failed (see evidence JSON for details).";
+    const hint = validatePathForError ? `\n\nevidence:\n- ${path.relative(gitRoot, validatePathForError)}` : "";
+    errorToThrow = new deps.UserError("Failed to generate evidence due to strict validation errors.", { details: `${details}${hint}` });
+  }
+
+  return {
+    output: outputLines.join("\n") + "\n",
+    errorToThrow,
+  };
+}

package/src/commands/change-evidence-entry.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+
+/**
+ * @param {{
+ *   gitRoot: string,
+ *   changeId: string,
+ *   options: { noValidate: boolean, allowFail: boolean }
+ * }} input
+ * @param {{
+ *   changeDirAbs: (gitRoot: string, changeId: string) => string,
+ *   fileState: (changeDir: string, rel: string) => Promise<any>,
+ *   pathExists: (path: string) => Promise<boolean>,
+ *   runChangeEvidenceWorkflow: (input: any, deps: any) => Promise<{ output: string, errorToThrow: any }>,
+ *   workflowDeps: Record<string, any>,
+ *   UserError: typeof import("../errors.js").UserError
+ * }} deps
+ */
+export async function runChangeEvidenceCommand(input, deps) {
+  const { gitRoot, changeId, options } = input;
+  const changeDir = deps.changeDirAbs(gitRoot, changeId);
+  if (!(await deps.pathExists(changeDir))) {
+    throw new deps.UserError(`Missing change dir: ${path.relative(gitRoot, changeDir)}`);
+  }
+
+  const proposal = await deps.fileState(changeDir, "proposal.md");
+  if (proposal.state !== "ok") {
+    throw new deps.UserError("proposal.md is required for evidence generation.", { details: path.relative(gitRoot, proposal.abs) });
+  }
+
+  return deps.runChangeEvidenceWorkflow(
+    {
+      gitRoot,
+      changeId,
+      changeDir,
+      proposalText: proposal.text,
+      options,
+    },
+    deps.workflowDeps,
+  );
+}

package/src/commands/change-evidence.js

@@ -0,0 +1,338 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { pathExists } from "../fs.js";
+
+/**
+ * @param {string} input
+ */
+function normalizeSlashes(input) {
+  return String(input || "").replaceAll("\\", "/");
+}
+
+/**
+ * @param {string} gitRoot
+ * @param {string} absPath
+ */
+export function relFromRoot(gitRoot, absPath) {
+  return normalizeSlashes(path.relative(gitRoot, absPath));
+}
+
+/**
+ * @param {string} absDir
+ * @param {{ maxDepth?: number, maxFiles?: number }} [options]
+ * @returns {Promise<string[]>}
+ */
+async function listFilesRecursive(absDir, options) {
+  const maxDepth = Number(options?.maxDepth ?? 4);
+  const maxFiles = Number(options?.maxFiles ?? 200);
+  /** @type {string[]} */
+  const out = [];
+
+  /** @param {string} curAbs @param {number} depth */
+  async function walk(curAbs, depth) {
+    if (depth > maxDepth) return;
+    let entries = [];
+    try {
+      entries = await fs.readdir(curAbs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (out.length >= maxFiles) return;
+      const nextAbs = path.join(curAbs, entry.name);
+      if (entry.isDirectory()) {
+        await walk(nextAbs, depth + 1);
+        continue;
+      }
+      if (entry.isFile()) out.push(nextAbs);
+    }
+  }
+
+  if (!(await pathExists(absDir))) return out;
+  await walk(absDir, 0);
+  return out;
+}
+
+/**
+ * @param {string} gitRoot
+ * @param {string} changeDir
+ */
+export async function collectCollaborationArtifacts(gitRoot, changeDir) {
+  const groups = [
+    ["analysis", "analysis"],
+    ["patches", "patches"],
+    ["review", "review"],
+    ["evidence", "evidence"],
+  ];
+
+  /** @type {Record<string, { label: string, dir: string, exists: boolean, count: number, files: string[], truncated: boolean }>} */
+  const dirs = {};
+  const counts = {
+    analysis: 0,
+    patches: 0,
+    review: 0,
+    evidence: 0,
+    total: 0,
+  };
+
+  for (const [key, label] of groups) {
+    const abs = path.join(changeDir, key);
+    const exists = await pathExists(abs);
+    const filesAbs = exists ? await listFilesRecursive(abs, { maxDepth: 4, maxFiles: 200 }) : [];
+    const files = filesAbs.map((item) => relFromRoot(gitRoot, item));
+    dirs[key] = {
+      label,
+      dir: relFromRoot(gitRoot, abs),
+      exists,
+      count: files.length,
+      files: files.slice(0, 8),
+      truncated: files.length > 8,
+    };
+    counts[key] = files.length;
+    counts.total += files.length;
+  }
+
+  return { dirs, counts };
+}
+
+/**
+ * Evidence_Path is user-declared; we treat it as best-effort hints, not hard gates.
+ *
+ * @param {string} gitRoot
+ * @param {string} changeId
+ * @param {string[]} evidencePaths
+ * @returns {Promise<{
+ *   entries: Array<{rel: string, abs: string, exists: boolean, kind: string, isAbsolute: boolean}>,
+ *   counts: { total: number, exists: number, missing: number, tmp: number, persistent: number, other: number, absolute: number },
+ *   missing: string[]
+ * }>}
+ */
+export async function analyzeEvidencePaths(gitRoot, changeId, evidencePaths) {
+  const changePrefix = `changes/${changeId}/`;
+  const evidencePrefix = `changes/${changeId}/evidence/`;
+  const reviewPrefix = `changes/${changeId}/review/`;
+
+  const entries = await Promise.all(
+    (evidencePaths || []).map(async (raw) => {
+      const rel = String(raw || "").trim();
+      const isAbsolute = path.isAbsolute(rel);
+      const abs = isAbsolute ? rel : path.join(gitRoot, rel);
+      const exists = rel ? await pathExists(abs) : false;
+
+      const relNorm = normalizeSlashes(rel);
+      let kind = "other";
+      if (relNorm.startsWith(".agentdocs/tmp/") || relNorm.startsWith(".agentdocs/")) kind = "tmp";
+      else if (relNorm.startsWith(evidencePrefix) || relNorm.startsWith(reviewPrefix) || relNorm.startsWith(changePrefix)) kind = "persistent";
+
+      return { rel, abs: path.resolve(abs), exists, kind, isAbsolute };
+    }),
+  );
+
+  const missing = entries.filter((entry) => entry.rel && !entry.exists).map((entry) => entry.rel);
+  const counts = {
+    total: entries.filter((entry) => entry.rel).length,
+    exists: entries.filter((entry) => entry.rel && entry.exists).length,
+    missing: missing.length,
+    tmp: entries.filter((entry) => entry.rel && entry.kind === "tmp").length,
+    persistent: entries.filter((entry) => entry.rel && entry.kind === "persistent").length,
+    other: entries.filter((entry) => entry.rel && entry.kind === "other").length,
+    absolute: entries.filter((entry) => entry.rel && entry.isAbsolute).length,
+  };
+
+  return { entries: entries.filter((entry) => entry.rel), counts, missing };
+}
+
+/**
+ * @param {string[]} a
+ * @param {string[]} b
+ */
+export function mergeDeclaredValues(a, b) {
+  const seen = new Set();
+  /** @type {string[]} */
+  const out = [];
+  for (const raw of [...(a || []), ...(b || [])]) {
+    const value = String(raw || "").trim().replace(/^`+/, "").replace(/`+$/, "").trim();
+    if (!value) continue;
+    if (seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+/**
+ * @param {string[]} values
+ */
+export function formatDeclaredValues(values) {
+  return (values || []).join(", ");
+}
+
+/**
+ * @param {string} input
+ */
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Replace or insert a simple "ID: value" style line in Markdown.
+ *
+ * @param {string} text
+ * @param {string[]} labelCandidates
+ * @param {string} value
+ * @param {{ insertAfterLabels?: string[] }} options
+ */
+export function upsertIdLine(text, labelCandidates, value, options) {
+  const src = String(text || "");
+  const labels = Array.isArray(labelCandidates) ? labelCandidates : [];
+  for (const label of labels) {
+    const re = new RegExp(`^(.*${escapeRegExp(label)}.*?[:=][ \\t]*)(.*)$`, "m");
+    const match = re.exec(src);
+    if (!match) continue;
+    const prefix = match[1] || "";
+    const replaced = src.replace(re, `${prefix}${value}`);
+    return { ok: true, changed: replaced !== src, text: replaced, mode: "replaced", label };
+  }
+
+  const insertAfter = Array.isArray(options?.insertAfterLabels) ? options.insertAfterLabels : [];
+  const lines = src.split(/\r?\n/);
+  let idx = 0;
+  for (let i = 0; i < Math.min(lines.length, 80); i++) {
+    const line = lines[i] || "";
+    if (insertAfter.some((label) => line.includes(label))) idx = i + 1;
+  }
+  const insertedLabel = labels[0] || "Evidence_Path";
+  lines.splice(idx, 0, `- ${insertedLabel}: ${value}`);
+  const inserted = lines.join("\n");
+  return { ok: true, changed: inserted !== src, text: inserted, mode: "inserted", label: labels[0] || "" };
+}
+
+/**
+ * Special-case insertion for proposal.md template style.
+ *
+ * @param {string} proposalText
+ * @param {string} value
+ */
+export function upsertProposalEvidencePath(proposalText, value) {
+  const src = String(proposalText || "");
+  const re = new RegExp(`^(.*${escapeRegExp("Evidence_Path")}.*?[:=][ \\t]*)(.*)$`, "m");
+  if (re.test(src)) {
+    const match = re.exec(src);
+    const prefix = match?.[1] || "";
+    const out = src.replace(re, `${prefix}${value}`);
+    return { changed: out !== src, text: out, mode: "replaced" };
+  }
+  const lines = src.split(/\r?\n/);
+  let idx = 0;
+  for (let i = 0; i < Math.min(lines.length, 120); i++) {
+    if ((lines[i] || "").includes("Plan_File")) {
+      idx = i + 1;
+      break;
+    }
+  }
+  lines.splice(idx, 0, `- \`Evidence_Path\` = ${value}`);
+  const inserted = lines.join("\n");
+  return { changed: inserted !== src, text: inserted, mode: "inserted" };
+}
+
+/**
+ * @param {string} changeId
+ */
+export function planVerifyHint(changeId) {
+  return `执行前质量门（优先）：\`aiws change validate ${changeId} --strict\`（AI 工具中等价于 \`$ws-plan-verify\`）`;
+}
+
+/**
+ * @param {string} absDir
+ * @param {(fileName: string) => boolean} predicate
+ */
+export async function findLatestFileByMtime(absDir, predicate) {
+  /** @type {Array<{ abs: string, mtimeMs: number }>} */
+  const matches = [];
+  if (!(await pathExists(absDir))) return "";
+  try {
+    const entries = await fs.readdir(absDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!predicate(entry.name)) continue;
+      const abs = path.join(absDir, entry.name);
+      const st = await fs.stat(abs);
+      matches.push({ abs, mtimeMs: st.mtimeMs });
+    }
+  } catch {
+    return "";
+  }
+  matches.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return matches[0]?.abs || "";
+}
+
+/**
+ * @param {{
+ *   gitRoot: string,
+ *   changeId: string,
+ *   branch: string,
+ *   status: any,
+ *   collaboration: any,
+ *   created: string[],
+ *   validateRes: any,
+ *   validateFailed: boolean
+ * }} options
+ */
+export function buildDeliverySummary(options) {
+  const { gitRoot, changeId, branch, status, collaboration, created, validateRes, validateFailed } = options;
+  /** @type {string[]} */
+  const lines = [];
+  lines.push(`# Delivery Summary: ${changeId}`);
+  lines.push("");
+  lines.push(`Generated: ${new Date().toISOString().replace(/\.\d{3}Z$/, "Z")}`);
+  lines.push("");
+  lines.push("## Context");
+  lines.push(`- Worktree: \`${gitRoot}\``);
+  lines.push(`- Branch: \`${branch || "(detached)"}\``);
+  lines.push("");
+  lines.push("## Status");
+  lines.push(`- Phase: \`${status.phase}\``);
+  lines.push(`- Tasks: ${status.tasks.done}/${status.tasks.total} (unchecked=${status.tasks.unchecked})`);
+  lines.push(`- Truth drift: ${status.driftFiles.length > 0 ? status.driftFiles.join(", ") : "(none)"}`);
+  lines.push("");
+  lines.push("## Collaboration");
+  lines.push(`- analysis: ${collaboration.counts.analysis}`);
+  lines.push(`- patches: ${collaboration.counts.patches}`);
+  lines.push(`- review: ${collaboration.counts.review}`);
+  lines.push(`- evidence dir files: ${collaboration.counts.evidence}`);
+  for (const key of ["analysis", "patches", "review"]) {
+    const group = collaboration.dirs[key];
+    if (!group || group.count === 0) continue;
+    lines.push(`- ${group.label} files:`);
+    for (const rel of group.files) lines.push(`  - \`${rel}\``);
+    if (group.truncated) lines.push("  - ...(truncated)");
+  }
+  lines.push("");
+  lines.push("## Bindings");
+  if (status.reqId) lines.push(`- Req_ID: \`${status.reqId}\``);
+  if (status.probId) lines.push(`- Problem_ID: \`${status.probId}\``);
+  if (status.bindings?.contractRow) lines.push(`- Contract_Row: \`${status.bindings.contractRow}\``);
+  if (status.bindings?.planFile) lines.push(`- Plan_File: \`${status.bindings.planFile}\``);
+  lines.push("");
+  lines.push("## Evidence (Created/Collected)");
+  if (created.length === 0) lines.push("- (none)");
+  else for (const item of created) lines.push(`- \`${item}\``);
+  lines.push("");
+  lines.push("## Quality Gate");
+  if (!validateRes) {
+    lines.push("- Strict validation: (skipped via --no-validate)");
+  } else {
+    lines.push(`- Strict validation ok: \`${validateRes.ok === true}\``);
+    lines.push(`- Errors: \`${Array.isArray(validateRes.errors) ? validateRes.errors.length : 0}\``);
+    lines.push(`- Warnings: \`${Array.isArray(validateRes.warnings) ? validateRes.warnings.length : 0}\``);
+  }
+  lines.push("");
+  lines.push("## Next");
+  lines.push(`- ${planVerifyHint(changeId)}`);
+  if (validateFailed) lines.push("- Fix strict validation errors, then re-run `aiws change evidence`");
+  else lines.push(`- Verify evidence gate: \`aiws change validate ${changeId} --strict --check-evidence\``);
+  if (collaboration.counts.patches > 0) lines.push("- Review delegated patch drafts before apply/merge; do not treat `changes/<id>/patches/` as auto-applied changes");
+  if (collaboration.counts.analysis > 0 && collaboration.counts.review === 0) lines.push("- Summarize delegated analysis into `changes/<id>/review/` before delivery");
+  return lines.join("\n") + "\n";
+}