@xenonbyte/da-vinci-workflow 0.1.23 → 0.1.25

package/references/artifact-templates.md

@@ -559,6 +559,8 @@ Use this structure:
 
 ## Design-Supervisor Review
 - Configured reviewers
+- Executed reviewers
+- Review source (`skill` / `manual` / `inferred`)
 - Review mode
 - Review inputs
 - Whether reviewers were distinct from `Preferred adapters`
@@ -567,6 +569,7 @@ Use this structure:
 - Revision outcome
 - Whether broad expansion is approved
 - Whether implementation-task handoff is approved
+- Keep one canonical structured supervisor-review section; avoid ad-hoc headings such as `## Design-Supervisor Review (Round X Attempt)`
 
 ## Anchor Surfaces
 - Which 1-3 anchor screens were designed first

package/scripts/test-audit-design-supervisor.js

@@ -5,6 +5,7 @@ const path = require("path");
 const { spawnSync } = require("child_process");
 
 const { auditProject } = require("../lib/audit");
+const { inspectDesignSupervisorReview } = require("../lib/audit-parsers");
 
 const repo = path.resolve(__dirname, "..");
 const cli = path.join(repo, "bin", "da-vinci.js");
@@ -318,6 +319,8 @@ runTest("completion audit passes when required supervisor review is recorded as
       "",
       "## Design-Supervisor Review",
       "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
       "- Review mode: screenshot-and-theme",
       "- Review inputs: screenshots, pencil variables, visual thesis, content plan, interaction thesis",
       "- Status: PASS",
@@ -345,4 +348,344 @@ runTest("completion audit passes when required supervisor review is recorded as
   );
 });
 
+runTest("completion audit accepts the latest structured round section when multiple Design-Supervisor Review headings exist", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "latest-supervisor-round-wins", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: BLOCK",
+      "- Issue list: command not found",
+      "- Revision outcome: blocked",
+      "",
+      "## Design-Supervisor Review (Round 2 Attempt)",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: accepted",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(
+    result.status,
+    "PASS",
+    `expected completion audit to use latest review section:\n${JSON.stringify(result, null, 2)}`
+  );
+  assert.match(
+    result.notes.join("\n"),
+    /Detected design-supervisor review status PASS/i
+  );
+  assert.doesNotMatch(
+    result.warnings.join("\n"),
+    /legacy\/non-structured format/i
+  );
+});
+
+runTest("completion audit falls back to the latest structured section when newest review entry is legacy-style", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "legacy-supervisor-entry-fallback", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      "",
+      "## Design-Supervisor Review (Round 2 Attempt)",
+      "- Result: BLOCK",
+      "- Issue list: style quality not approved",
+      "- Revision outcome: pending",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(
+    result.status,
+    "WARN",
+    `expected completion audit to warn but not fail when latest entry is legacy:\n${JSON.stringify(result, null, 2)}`
+  );
+  assert.match(
+    result.notes.join("\n"),
+    /Detected design-supervisor review status PASS/i
+  );
+  assert.match(
+    result.warnings.join("\n"),
+    /legacy\/non-structured format; gate evaluation used ## Design-Supervisor Review/i
+  );
+});
+
+runTest("completion audit fails when only legacy-style Design-Supervisor Review sections exist", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "legacy-supervisor-only", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review (Round 3 Attempt)",
+      "- Result: PASS",
+      "- Issue list: none",
+      "- Revision outcome: accepted",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(result.status, "FAIL");
+  assert.match(
+    result.failures.join("\n"),
+    /missing required field\(s\): Configured reviewers/i
+  );
+});
+
+runTest("completion audit treats Chinese round-attempt heading as legacy and falls back to latest structured section", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "legacy-supervisor-chinese-heading", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      "",
+      "## Design-Supervisor Review（第2轮尝试）",
+      "- Result: BLOCK",
+      "- Issue list: 视觉层级仍需调整",
+      "- Revision outcome: 待修订",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(result.status, "WARN");
+  assert.match(
+    result.warnings.join("\n"),
+    /legacy\/non-structured format; gate evaluation used ## Design-Supervisor Review/i
+  );
+  assert.match(
+    result.notes.join("\n"),
+    /Detected design-supervisor review status PASS/i
+  );
+});
+
+runTest("inspectDesignSupervisorReview marks Chinese round-attempt suffix as legacy", () => {
+  const review = inspectDesignSupervisorReview(
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      "",
+      "## Design-Supervisor Review（第3轮尝试）",
+      "- Result: BLOCK",
+      "- Issue list: 继续迭代",
+      "- Revision outcome: pending",
+      ""
+    ].join("\n")
+  );
+
+  assert.equal(review.found, true);
+  assert.equal(review.latestSectionLooksLegacyAttempt, true);
+  assert.equal(review.usedStructuredSectionFallback, true);
+  assert.equal(review.selectedFromLatest, false);
+  assert.equal(review.status, "PASS");
+});
+
+runTest("completion audit accepts multiline Issue list and Revision outcome fields", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "multiline-supervisor-fields", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: WARN",
+      "- Issue list:",
+      "  - icon alignment drift on top bar",
+      "  - hierarchy contrast needs one more pass",
+      "- Revision outcome:",
+      "  - accepted with follow-up in next visual pass",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(
+    result.status,
+    "PASS",
+    `expected accepted WARN with multiline fields to pass:\n${JSON.stringify(result, null, 2)}`
+  );
+  assert.match(
+    result.notes.join("\n"),
+    /Detected design-supervisor review status WARN/i
+  );
+});
+
+runTest("completion audit fails when required supervisor review is not skill-backed", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "required-supervisor-skill-source", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Review source: inferred",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(result.status, "FAIL");
+  assert.match(
+    result.failures.join("\n"),
+    /must be skill-backed.*Require Supervisor Review: true/i
+  );
+});
+
+runTest("completion audit fails when required supervisor review omits executed reviewers", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "required-supervisor-executed-missing", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(result.status, "FAIL");
+  assert.match(
+    result.failures.join("\n"),
+    /missing required field\(s\): Executed reviewers/i
+  );
+});
+
+runTest("completion audit fails when required supervisor review did not execute all configured reviewers", () => {
+  const harness = createHarness();
+  const project = setupProject(harness, "required-supervisor-executed-incomplete", {
+    requireSupervisorReview: true
+  });
+
+  writeText(
+    project.pencilDesignPath,
+    [
+      "# Pencil Design",
+      "",
+      "## Design-Supervisor Review",
+      "- Configured reviewers: frontend-skill",
+      "- Executed reviewers: ui-ux-pro-max",
+      "- Review source: skill",
+      "- Status: PASS",
+      "- Issue list: none",
+      "- Revision outcome: approved",
+      ""
+    ].join("\n")
+  );
+
+  const result = auditProject(project.root, {
+    mode: "completion",
+    changeId
+  });
+
+  assert.equal(result.status, "FAIL");
+  assert.match(
+    result.failures.join("\n"),
+    /did not execute configured reviewer skill\(s\): frontend-skill/i
+  );
+});
+
 console.log("All design-supervisor audit tests passed.");

package/scripts/test-mode-consistency.js

@@ -283,6 +283,11 @@ runTest("design-supervisor review stays distinct from preferred adapters and is
     const content = read(file);
     assert.match(content, /design-supervisor review/, `${file} should instruct design flows to run design-supervisor review when configured`);
     assert.match(content, /Require Supervisor Review: true/, `${file} should explain the hard-gate branch for supervisor review`);
+    assert.doesNotMatch(
+      content,
+      /^\s*##\s*Design-Supervisor Review\s*\(Round [^)]+Attempt\)\s*$/im,
+      `${file} should not provide ad-hoc supervisor-review heading templates`
+    );
   }
 });
 

package/scripts/test-pen-persistence.js

@@ -33,6 +33,10 @@ function createTempDir() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-pen-persistence-"));
 }
 
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 function writePayloadFiles(tempDir, fixture) {
   const nodesFile = path.join(tempDir, "nodes.json");
   const variablesFile = path.join(tempDir, "variables.json");
@@ -183,6 +187,151 @@ runTest("comparePenSync fails when live payload is newer than disk", () => {
   assert.notEqual(result.liveHash, result.persistedHash);
 });
 
+runTest("writePenFromPayloadFiles rejects pen-state metadata passed as nodes payload", () => {
+  const tempDir = createTempDir();
+  const outputPath = path.join(tempDir, "written.pen");
+  const nodesFile = path.join(tempDir, "state-like.json");
+
+  fs.writeFileSync(
+    nodesFile,
+    JSON.stringify(
+      {
+        schema: 1,
+        penPath: "/tmp/demo.pen",
+        snapshotHash: "abc123",
+        topLevelIds: [],
+        topLevelCount: 0
+      },
+      null,
+      2
+    )
+  );
+
+  assert.throws(
+    () =>
+      writePenFromPayloadFiles({
+        outputPath,
+        nodesFile
+      }),
+    /appears to be pen state metadata/i
+  );
+});
+
+runTest("comparePenSync rejects pen-state metadata passed as nodes payload", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const { nodesFile, variablesFile } = writePayloadFiles(tempDir, fixture);
+  const outputPath = path.join(tempDir, "written.pen");
+  const invalidNodesFile = path.join(tempDir, "state-like.json");
+
+  writePenFromPayloadFiles({
+    outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  fs.writeFileSync(
+    invalidNodesFile,
+    JSON.stringify(
+      {
+        schema: 1,
+        penPath: outputPath,
+        snapshotHash: "abc123",
+        topLevelIds: fixture.children.map((node) => node.id),
+        topLevelCount: fixture.children.length
+      },
+      null,
+      2
+    )
+  );
+
+  assert.throws(
+    () =>
+      comparePenSync({
+        penPath: outputPath,
+        nodesFile: invalidNodesFile,
+        version: fixture.version
+      }),
+    /appears to be pen state metadata/i
+  );
+});
+
+runTest("writePenFromPayloadFiles accepts nodes payload even when metadata keys are present", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const nodesFile = path.join(tempDir, "nodes-with-metadata.json");
+  const variablesFile = path.join(tempDir, "variables.json");
+  const outputPath = path.join(tempDir, "written.pen");
+
+  fs.writeFileSync(
+    nodesFile,
+    JSON.stringify(
+      {
+        nodes: fixture.children,
+        penPath: "/tmp/demo.pen",
+        snapshotHash: "abc123",
+        topLevelIds: fixture.children.map((node) => node.id),
+        topLevelCount: fixture.children.length
+      },
+      null,
+      2
+    )
+  );
+  fs.writeFileSync(variablesFile, JSON.stringify({ variables: fixture.variables }, null, 2));
+
+  writePenFromPayloadFiles({
+    outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf8")), fixture);
+});
+
+runTest("writePenFromPayloadFiles shows relative nodes path in metadata-payload error when file is under cwd", () => {
+  const originalCwd = process.cwd();
+  const localRoot = fs.mkdtempSync(path.join(originalCwd, ".tmp-da-vinci-pen-path-"));
+
+  try {
+    process.chdir(localRoot);
+    const outputPath = path.join(localRoot, "written.pen");
+    const nodesFile = path.join(localRoot, "state-like.json");
+
+    fs.writeFileSync(
+      nodesFile,
+      JSON.stringify(
+        {
+          schema: 1,
+          penPath: "/tmp/demo.pen",
+          snapshotHash: "abc123",
+          topLevelIds: [],
+          topLevelCount: 0
+        },
+        null,
+        2
+      )
+    );
+
+    assert.throws(
+      () =>
+        writePenFromPayloadFiles({
+          outputPath,
+          nodesFile
+        }),
+      (error) => {
+        assert.match(error.message, /\(state-like\.json\)/i);
+        assert.doesNotMatch(error.message, new RegExp(escapeRegExp(localRoot)));
+        return true;
+      }
+    );
+  } finally {
+    process.chdir(originalCwd);
+    fs.rmSync(localRoot, { recursive: true, force: true });
+  }
+});
+
 runTest("global Pencil lock serializes projects", () => {
   const tempDir = createTempDir();
   const homeDir = path.join(tempDir, "home");