@xenonbyte/da-vinci-workflow 0.1.26 → 0.2.2

package/lib/artifact-parsers.js

@@ -0,0 +1,120 @@
+const { getMarkdownSection, hasMarkdownHeading } = require("./audit-parsers");
+
+const RUNTIME_SPEC_SECTION_DEFS = [
+  {
+    id: "capability",
+    heading: "Capability",
+    required: false
+  },
+  {
+    id: "behavior",
+    heading: "Behavior",
+    required: true
+  },
+  {
+    id: "states",
+    heading: "States",
+    required: true
+  },
+  {
+    id: "inputs",
+    heading: "Inputs",
+    required: true
+  },
+  {
+    id: "outputs",
+    heading: "Outputs",
+    required: true
+  },
+  {
+    id: "acceptance",
+    heading: "Acceptance",
+    required: true
+  },
+  {
+    id: "edgeCases",
+    heading: "Edge Cases",
+    required: true
+  }
+];
+
+const LIST_ITEM_PATTERN = /^\s*(?:[-*+]|\d+[.)])\s+(.+?)\s*$/;
+
+function extractSectionItems(sectionText) {
+  const normalized = String(sectionText || "").replace(/\r\n?/g, "\n").trim();
+  if (!normalized) {
+    return [];
+  }
+
+  const lines = normalized.split("\n");
+  const listItems = [];
+  for (const line of lines) {
+    const match = line.match(LIST_ITEM_PATTERN);
+    if (!match) {
+      continue;
+    }
+    const value = String(match[1] || "").trim();
+    if (value) {
+      listItems.push(value);
+    }
+  }
+
+  if (listItems.length > 0) {
+    return listItems;
+  }
+
+  return normalized
+    .split(/\n\s*\n/g)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseRuntimeSpecMarkdown(markdownText) {
+  const source = String(markdownText || "");
+  const sections = {};
+  const missingSections = [];
+  const emptySections = [];
+
+  for (const sectionDef of RUNTIME_SPEC_SECTION_DEFS) {
+    const present = hasMarkdownHeading(source, sectionDef.heading, {
+      allowParentheticalSuffix: true
+    });
+    const raw = getMarkdownSection(source, sectionDef.heading, {
+      allowParentheticalSuffix: true
+    });
+    const empty = present && String(raw || "").trim() === "";
+    const items = extractSectionItems(raw);
+
+    sections[sectionDef.id] = {
+      heading: sectionDef.heading,
+      required: sectionDef.required,
+      present,
+      empty,
+      raw,
+      items
+    };
+
+    if (!sectionDef.required) {
+      continue;
+    }
+
+    if (!present) {
+      missingSections.push(sectionDef.heading);
+      continue;
+    }
+    if (empty) {
+      emptySections.push(sectionDef.heading);
+    }
+  }
+
+  return {
+    sections,
+    missingSections,
+    emptySections
+  };
+}
+
+module.exports = {
+  RUNTIME_SPEC_SECTION_DEFS,
+  parseRuntimeSpecMarkdown
+};

package/lib/audit.js

@@ -11,6 +11,7 @@ const { getSessionStatePath, readSessionState } = require("./pencil-session");
 const { isPathInside, listFilesRecursiveSafe } = require("./fs-safety");
 const { pathExists, readTextIfExists } = require("./utils");
 const { runModuleExportInWorker } = require("./async-offload");
+const { readExecutionSignals, summarizeSignalsBySurface } = require("./execution-signals");
 const {
   normalizeCheckpointLabel,
   parseCheckpointStatusMap,
@@ -38,6 +39,13 @@ const EXPORT_SCAN_LIMITS = Object.freeze({
   maxDepth: 4,
   maxEntries: 1200
 });
+const PLANNING_SIGNAL_SURFACES = new Set(["lint-spec", "scope-check", "lint-tasks", "lint-bindings"]);
+const VERIFICATION_SIGNAL_SURFACES = new Set([
+  "verify-bindings",
+  "verify-implementation",
+  "verify-structure",
+  "verify-coverage"
+]);
 
 function listFilesRecursive(rootDir, limits = {}) {
   return listFilesRecursiveSafe(rootDir, {
@@ -253,6 +261,17 @@ function auditProject(projectPathInput, options = {}) {
 
   if (!pathExists(daVinciDir)) {
     failures.push("Missing `.da-vinci/` directory.");
+    addMissingArtifacts(projectRoot, [path.join(projectRoot, "DA-VINCI.md"), designsDir], failures);
+    const missingWorkflowArtifacts = [
+      path.join(daVinciDir, "project-inventory.md"),
+      path.join(daVinciDir, "page-map.md"),
+      designRegistryPath
+    ];
+    if (mode === "completion") {
+      addMissingArtifacts(projectRoot, missingWorkflowArtifacts, failures);
+    } else {
+      addMissingArtifacts(projectRoot, missingWorkflowArtifacts, warnings);
+    }
     notes.push(
       `Hint: scaffold the required workflow files with \`${buildBootstrapCommand(projectRoot, mode, options.changeId || null)}\`.`
     );
@@ -814,6 +833,48 @@ function auditProject(projectPathInput, options = {}) {
     }
   }
 
+  const signalSummary =
+    options && options.preloadedSignalSummary && typeof options.preloadedSignalSummary === "object"
+      ? options.preloadedSignalSummary
+      : summarizeSignalsBySurface(
+          readExecutionSignals(projectRoot, {
+            changeId: options.changeId || ""
+          })
+        );
+  for (const [surface, signal] of Object.entries(signalSummary)) {
+    if (surface === "signal-file-parse") {
+      const warningMessage =
+        Array.isArray(signal.warnings) && signal.warnings[0]
+          ? String(signal.warnings[0])
+          : "Malformed execution signal files were detected.";
+      pushUnique(warnings, warningMessage);
+      continue;
+    }
+
+    if (mode === "integrity" && PLANNING_SIGNAL_SURFACES.has(surface)) {
+      if (signal.status === "BLOCK") {
+        pushUnique(warnings, `Planning signal ${surface} is BLOCK (advisory in integrity mode).`);
+      } else if (signal.status === "WARN") {
+        pushUnique(notes, `Planning signal ${surface} is WARN.`);
+      }
+    }
+
+    if (mode === "completion" && VERIFICATION_SIGNAL_SURFACES.has(surface)) {
+      if (signal.status === "BLOCK") {
+        failures.push(`Verification signal ${surface} is BLOCK.`);
+      } else if (signal.status === "WARN") {
+        pushUnique(warnings, `Verification signal ${surface} is WARN.`);
+      }
+    }
+
+    if (surface === "diff-spec" && signal.status !== "PASS") {
+      pushUnique(warnings, `Planning diff signal ${surface} reports ${signal.status}.`);
+    }
+  }
+  notes.push(
+    "Execution-chain signal integration uses advisory planning semantics in integrity mode and blocking verification semantics in completion mode."
+  );
+
   const status = failures.length > 0 ? "FAIL" : warnings.length > 0 ? "WARN" : "PASS";
 
   return {

package/lib/cli.js

@@ -54,11 +54,35 @@ const {
   bootstrapProjectArtifacts,
   formatBootstrapProjectReport
 } = require("./workflow-bootstrap");
+const {
+  deriveWorkflowStatus,
+  formatWorkflowStatusReport,
+  formatNextStepReport
+} = require("./workflow-state");
+const { lintRuntimeSpecs, formatLintSpecReport } = require("./lint-spec");
+const { runScopeCheck, formatScopeCheckReport } = require("./scope-check");
+const { lintTasks, formatLintTasksReport } = require("./lint-tasks");
+const { lintBindings, formatLintBindingsReport } = require("./lint-bindings");
+const { generatePlanningSidecars, formatGenerateSidecarsReport } = require("./sidecars");
+const {
+  verifyBindings,
+  verifyImplementation,
+  verifyStructure,
+  verifyCoverage,
+  formatVerifyReport
+} = require("./verify");
+const { diffSpec, formatDiffSpecReport } = require("./diff-spec");
+const { scaffoldFromBindings, formatScaffoldReport } = require("./scaffold");
+const { writeExecutionSignal } = require("./execution-signals");
+const { formatTuiHelp, launchTui } = require("../tui");
 
 const DEFAULT_MAX_PREFLIGHT_STDIN_BYTES = 1024 * 1024;
+const DEFAULT_MAX_STDIN_TRANSIENT_RETRIES = 2000;
+const DEFAULT_MAX_STDIN_TRANSIENT_BACKOFF_MS = 25;
 const OPTION_FLAGS_WITH_VALUES = new Set([
   "--home",
   "--platform",
+  "--lang",
   "--project",
   "--mode",
   "--change",
@@ -98,6 +122,7 @@ const OPTION_FLAGS_WITH_VALUES = new Set([
 
 const HELP_OPTION_SPECS = [
   { flag: "--platform <value>", description: "codex, claude, gemini, or all" },
+  { flag: "--lang <value>", description: "ui language for `da-vinci tui`: en or zh" },
   { flag: "--home <path>", description: "override HOME for installation targets" },
   { flag: "--project <path>", description: "override project path for audit" },
   {
@@ -159,10 +184,20 @@ const HELP_OPTION_SPECS = [
   { flag: "--revision-outcome <text>", description: "supervisor-review revision result summary" },
   { flag: "--top <value>", description: "icon-search result count (1-50, default 8)" },
   { flag: "--timeout-ms <value>", description: "network timeout for icon-sync requests" },
-  { flag: "--strict", description: "fail icon-sync when any upstream source request fails" },
-  { flag: "--json", description: "print structured JSON for icon-search" },
+  {
+    flag: "--strict",
+    description: "enable strict failure mode for commands that support advisory defaults (for example icon-sync, lint-spec)"
+  },
+  {
+    flag: "--continue-on-error",
+    description: "print BLOCK/FAIL command results without throwing process errors"
+  },
+  { flag: "--json", description: "print structured JSON output when supported by the command" },
   { flag: "--pen <path>", description: "registered .pen path for sync checks" },
-  { flag: "--from <path>", description: "source .pen path for sync-pen-source" },
+  {
+    flag: "--from <path>",
+    description: "source path for sync-pen-source, or baseline sidecars directory for diff-spec"
+  },
   { flag: "--to <path>", description: "destination .pen path for sync-pen-source" },
   { flag: "--ops-file <path>", description: "Pencil batch operations file for preflight" },
   { flag: "--input <path>", description: "input .pen file for snapshot-pen" },
@@ -178,11 +213,19 @@ const HELP_OPTION_SPECS = [
   { flag: "--force", description: "overwrite bootstrap placeholders or force commands that explicitly support it" }
 ];
 
-function readLimitedStdin(maxBytes = DEFAULT_MAX_PREFLIGHT_STDIN_BYTES) {
+function readLimitedStdin(maxBytes = DEFAULT_MAX_PREFLIGHT_STDIN_BYTES, options = {}) {
   const limit =
     Number.isFinite(Number(maxBytes)) && Number(maxBytes) > 0
       ? Number(maxBytes)
       : DEFAULT_MAX_PREFLIGHT_STDIN_BYTES;
+  const maxTransientRetries =
+    Number.isFinite(Number(options.maxTransientRetries)) && Number(options.maxTransientRetries) >= 0
+      ? Number(options.maxTransientRetries)
+      : DEFAULT_MAX_STDIN_TRANSIENT_RETRIES;
+  const maxBackoffMs =
+    Number.isFinite(Number(options.maxBackoffMs)) && Number(options.maxBackoffMs) > 0
+      ? Number(options.maxBackoffMs)
+      : DEFAULT_MAX_STDIN_TRANSIENT_BACKOFF_MS;
   const chunks = [];
   let totalBytes = 0;
   let transientReadRetries = 0;
@@ -195,7 +238,12 @@ function readLimitedStdin(maxBytes = DEFAULT_MAX_PREFLIGHT_STDIN_BYTES) {
     } catch (error) {
       if (error && (error.code === "EAGAIN" || error.code === "EINTR")) {
         transientReadRetries += 1;
-        sleepSyncMs(Math.min(5 * transientReadRetries, 25));
+        if (transientReadRetries > maxTransientRetries) {
+          throw new Error(
+            `Unable to read stdin after ${transientReadRetries} transient retry attempts (${error.code}).`
+          );
+        }
+        sleepSyncMs(Math.min(5 * transientReadRetries, maxBackoffMs));
         continue;
       }
       throw error;
@@ -285,6 +333,21 @@ function getOptionValues(args, name) {
     .map((entry) => entry.value);
 }
 
+function shouldContinueOnError(args) {
+  return Array.isArray(args) && args.includes("--continue-on-error");
+}
+
+function emitOrThrowOnStatus(status, blockedStatuses, output, continueOnError) {
+  if (!Array.isArray(blockedStatuses) || !blockedStatuses.includes(status)) {
+    return false;
+  }
+  if (continueOnError) {
+    console.log(output);
+    return true;
+  }
+  throw new Error(output);
+}
+
 function getIntegerOption(args, name, options = {}) {
   const raw = getOption(args, name);
   if (raw === undefined) {
@@ -372,6 +435,32 @@ function appendStatusIssues(lines, label, missing = [], mismatched = [], unreada
   }
 }
 
+function persistExecutionSignal(projectPath, changeId, surface, result, strict = false) {
+  try {
+    writeExecutionSignal(projectPath, {
+      changeId: changeId || "global",
+      surface,
+      status: result.status,
+      advisory: strict ? false : true,
+      strict,
+      failures: result.failures || [],
+      warnings: result.warnings || [],
+      notes: result.notes || []
+    });
+  } catch (error) {
+    // Signals are advisory metadata and should not break command execution.
+    const code = error && error.code ? String(error.code).toUpperCase() : "";
+    if (code === "EACCES" || code === "ENOSPC") {
+      return;
+    }
+
+    const message = error && error.message ? error.message : String(error);
+    console.error(
+      `Warning: failed to persist execution signal (${surface}) for change ${changeId || "global"}: ${message}`
+    );
+  }
+}
+
 function printHelp() {
   const optionLines = HELP_OPTION_SPECS.map((optionSpec) => {
     const paddedFlag = optionSpec.flag.padEnd(30, " ");
@@ -386,6 +475,20 @@ function printHelp() {
       "  da-vinci install --platform codex,claude,gemini",
       "  da-vinci uninstall --platform codex,claude,gemini",
       "  da-vinci status",
+      "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error]",
+      "  da-vinci workflow-status [--project <path>] [--change <id>] [--json]",
+      "  da-vinci next-step [--project <path>] [--change <id>] [--json]",
+      "  da-vinci lint-spec [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci scope-check [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci lint-tasks [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci lint-bindings [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci generate-sidecars [--project <path>] [--change <id>] [--json]",
+      "  da-vinci verify-bindings [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci verify-implementation [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci verify-structure [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci verify-coverage [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci diff-spec [--project <path>] [--change <id>] [--from <sidecars-dir>] [--json]",
+      "  da-vinci scaffold [--project <path>] [--change <id>] [--output <path>] [--json]",
       "  da-vinci validate-assets",
       "  da-vinci bootstrap-project --project <path> [--change <id>] [--force]",
       "  da-vinci audit [project-path]",
@@ -803,6 +906,7 @@ async function runCli(argv) {
   const [command] = argv;
   const homeDir = getOption(argv, "--home");
   const positionalArgs = getPositionalArgs(argv.slice(1), OPTION_FLAGS_WITH_VALUES);
+  const continueOnError = shouldContinueOnError(argv);
 
   if (!command || command === "help" || command === "--help" || command === "-h") {
     printHelp();
@@ -837,6 +941,235 @@ async function runCli(argv) {
     return;
   }
 
+  if (command === "tui") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const lang = getOption(argv, "--lang");
+    if (argv.includes("--help") || argv.includes("-h")) {
+      console.log(formatTuiHelp(lang));
+      return;
+    }
+    await launchTui({
+      projectPath,
+      changeId,
+      lang,
+      strict: argv.includes("--strict"),
+      jsonOutput: argv.includes("--json"),
+      continueOnError
+    });
+    return;
+  }
+
+  if (command === "workflow-status") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const result = deriveWorkflowStatus(projectPath, { changeId });
+
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    console.log(formatWorkflowStatusReport(result));
+    return;
+  }
+
+  if (command === "next-step") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const result = deriveWorkflowStatus(projectPath, { changeId });
+
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(result.nextStep || null, null, 2));
+      return;
+    }
+
+    console.log(formatNextStepReport(result));
+    return;
+  }
+
+  if (command === "lint-spec") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = lintRuntimeSpecs(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-spec", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatLintSpecReport(result);
+
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+
+    console.log(output);
+    return;
+  }
+
+  if (command === "scope-check") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = runScopeCheck(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "scope-check", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatScopeCheckReport(result);
+
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+
+    console.log(output);
+    return;
+  }
+
+  if (command === "lint-tasks") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = lintTasks(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-tasks", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatLintTasksReport(result);
+
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+
+    console.log(output);
+    return;
+  }
+
+  if (command === "lint-bindings") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = lintBindings(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-bindings", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatLintBindingsReport(result);
+
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+
+    console.log(output);
+    return;
+  }
+
+  if (command === "generate-sidecars") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const result = generatePlanningSidecars(projectPath, { changeId, write: true });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "generate-sidecars", result, false);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatGenerateSidecarsReport(result);
+
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+
+    console.log(output);
+    return;
+  }
+
+  if (command === "verify-bindings") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = verifyBindings(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-bindings", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson
+      ? JSON.stringify(result, null, 2)
+      : formatVerifyReport(result, "Da Vinci verify-bindings");
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "verify-implementation") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = verifyImplementation(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-implementation", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson
+      ? JSON.stringify(result, null, 2)
+      : formatVerifyReport(result, "Da Vinci verify-implementation");
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "verify-structure") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = verifyStructure(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-structure", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson
+      ? JSON.stringify(result, null, 2)
+      : formatVerifyReport(result, "Da Vinci verify-structure");
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "verify-coverage") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const strict = argv.includes("--strict");
+    const result = verifyCoverage(projectPath, { changeId, strict });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-coverage", result, strict);
+    const useJson = argv.includes("--json");
+    const output = useJson
+      ? JSON.stringify(result, null, 2)
+      : formatVerifyReport(result, "Da Vinci verify-coverage");
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "diff-spec") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const fromDir = getOption(argv, "--from");
+    const result = diffSpec(projectPath, { changeId, fromDir });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "diff-spec", result, false);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatDiffSpecReport(result);
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "scaffold") {
+    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
+    const changeId = getOption(argv, "--change");
+    const outputDir = getOption(argv, "--output");
+    const result = scaffoldFromBindings(projectPath, { changeId, outputDir });
+    persistExecutionSignal(projectPath, result.changeId || changeId, "scaffold", result, false);
+    const useJson = argv.includes("--json");
+    const output = useJson ? JSON.stringify(result, null, 2) : formatScaffoldReport(result);
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
   if (command === "validate-assets") {
     const result = validateAssets();
     console.log(`Da Vinci v${result.version} assets are complete (${result.requiredAssets} required files).`);
@@ -850,8 +1183,8 @@ async function runCli(argv) {
     const result = auditProject(projectPath, { mode, changeId });
     const report = formatAuditReport(result);
 
-    if (result.status === "FAIL") {
-      throw new Error(report);
+    if (emitOrThrowOnStatus(result.status, ["FAIL"], report, continueOnError)) {
+      return;
     }
 
     console.log(report);
@@ -903,8 +1236,8 @@ async function runCli(argv) {
     const result = preflightPencilBatch(operations);
     const report = formatPencilPreflightReport(result);
 
-    if (result.status === "FAIL") {
-      throw new Error(report);
+    if (emitOrThrowOnStatus(result.status, ["FAIL"], report, continueOnError)) {
+      return;
     }
 
     console.log(report);
@@ -1028,13 +1361,18 @@ async function runCli(argv) {
       preferredSource
     });
 
-    if (result.status === "BLOCK") {
-      throw new Error(
+    if (
+      emitOrThrowOnStatus(
+        result.status,
+        ["BLOCK"],
         [
           "Baseline alignment check failed.",
           formatPenBaselineAlignmentReport(result)
-        ].join("\n")
-      );
+        ].join("\n"),
+        continueOnError
+      )
+    ) {
+      return;
     }
 
     console.log(formatPenBaselineAlignmentReport(result));