@williambeto/ai-workflow 2.8.0 → 2.8.1

package/{chunk-Y4RLP6ZM.js → chunk-LD7EHAU2.js}

@@ -2,8 +2,9 @@ import {
   ArtifactFidelityGate,
   DeliveryDecisionEngine,
   MergeGate,
+  RequestRouter,
   StackDetector
-} from "./chunk-XW747GIG.js";
+} from "./chunk-H7GIKXFO.js";
 
 // src/core/validation/quality-guard.ts
 import { execSync } from "child_process";
@@ -39,19 +40,22 @@ var QualityGuard = class {
   evidencePolicy;
   riskLevel;
   _changedFiles;
+  scopedChangedFiles;
   _hasHead;
   constructor({
     cwd,
     taskSlug = null,
     evidenceWillBePersisted = false,
     evidencePolicy = "optional",
-    riskLevel = "medium"
+    riskLevel = "medium",
+    scopedChangedFiles = null
   }) {
     this.cwd = cwd;
     this.taskSlug = taskSlug;
     this.evidencePolicy = evidencePolicy || "optional";
     this.riskLevel = riskLevel || "medium";
     this._changedFiles = null;
+    this.scopedChangedFiles = scopedChangedFiles ? [...new Set(scopedChangedFiles.map(normalizePath).filter(Boolean))].sort() : null;
     this._hasHead = null;
     this.evidenceWillBePersisted = evidenceWillBePersisted;
   }
@@ -92,24 +96,27 @@ var QualityGuard = class {
     this._changedFiles = [...files].sort();
     return this._changedFiles;
   }
+  getScopedChangedFiles() {
+    return this.scopedChangedFiles ?? this.getChangedFiles();
+  }
   isDocsTask() {
-    const files = this.getChangedFiles();
+    const files = this.getScopedChangedFiles();
     return files.length > 0 && files.every((file) => file.endsWith(".md") || file.endsWith(".txt") || file.startsWith("docs/"));
   }
   isUiTask() {
-    return this.getChangedFiles().some(
+    return this.getScopedChangedFiles().some(
       (file) => /\.(tsx|jsx|vue|html|css|scss|less|blade\.php)$/.test(file) || /(^|\/)(components|pages|views)\//.test(file)
     );
   }
   isImplementationTask() {
-    const files = this.getChangedFiles();
+    const files = this.getScopedChangedFiles();
     if (files.length === 0 || this.isDocsTask()) return false;
     return files.some(
       (file) => file === "package.json" || /^(src|app|pages|components|server|api)\//.test(file) || /\.(js|jsx|ts|tsx|vue|php|py|rb|go|java|css|scss|html)$/.test(file)
     );
   }
-  async hasExecutableBehaviorChanges() {
-    const files = this.getChangedFiles().filter((file) => !isManagedChangePath(file));
+  async hasExecutableBehaviorChanges(filesOverride) {
+    const files = (filesOverride || this.getScopedChangedFiles()).filter((file) => !isManagedChangePath(file));
     const executableExtensions = /\.(js|jsx|mjs|cjs|ts|tsx|vue|php|py|rb|go|java|cs|rs|swift|kt|kts|sh|bash)$/i;
     if (files.some((file) => executableExtensions.test(file))) return true;
     for (const file of files.filter((item) => /\.(html?|xhtml)$/i.test(item))) {
@@ -141,12 +148,15 @@ var QualityGuard = class {
   }
   async verifyDocumentationNeed() {
     if (!this.isImplementationTask()) return { status: "NOT_RUN", reason: "No implementation changes detected." };
-    const files = this.getChangedFiles();
+    const files = this.getScopedChangedFiles();
     const docsChanged = files.some((file) => file === "README.md" || file.startsWith("docs/") || file.endsWith(".md"));
     const publicSurfaceChanged = files.some(
       (file) => file === "package.json" || /(^|\/)(routes?|api|cli|commands?|config|public)\//.test(file) || /README|CHANGELOG/.test(file)
     );
     if (publicSurfaceChanged && !docsChanged) {
+      if (this.evidencePolicy === "required") {
+        return { status: "FAIL_QUALITY_GATE", reason: "A required-evidence change modified a public API, CLI, configuration, or package surface without updating documentation." };
+      }
       return { status: "PASS_WITH_NOTES", reason: "Public behavior may have changed without a documentation update." };
     }
     return { status: "PASS" };
@@ -163,7 +173,11 @@ var QualityGuard = class {
         if (/\.(png|jpe?g|webp)$/i.test(String(entry))) found.push(normalizePath(path.join(dir, String(entry))));
       }
     }
-    return found.length ? { status: "PASS", screenshots: found.slice(0, 20) } : { status: "PASS_WITH_NOTES", reason: "UI changed without persisted screenshots; rely on the stated browser/manual review only if it actually occurred." };
+    if (found.length) return { status: "PASS", screenshots: found.slice(0, 20) };
+    if (this.evidencePolicy === "required") {
+      return { status: "FAIL_QUALITY_GATE", reason: "Required evidence for a high-risk or release UI change does not include a persisted screenshot." };
+    }
+    return { status: "PASS_WITH_NOTES", reason: "Screenshots are optional for this low/medium-risk UI change and were not persisted." };
   }
   async verifyPersistedEvidence() {
     if (this.evidencePolicy !== "required") return { status: "NOT_RUN", reason: "Persisted evidence is optional under optional evidence policy." };
@@ -373,13 +387,87 @@ var VisualVerifier = class {
 // src/core/validation/evidence-collector.ts
 import { spawnSync } from "child_process";
 import fs3 from "fs/promises";
+import fsSync from "fs";
 import path3 from "path";
+
+// src/core/completion-contract.ts
+var PASSING_VALIDATION = /* @__PURE__ */ new Set(["PASS", "PASS_WITH_NOTES"]);
+var TEST_FILE_PATTERN = /(^|\/)(__tests__|tests?)(\/|\.)|\.(test|spec)\.[cm]?[jt]sx?$/i;
+function parseDeliveryOutcomeClaim(output = "") {
+  const matches = [...String(output).matchAll(/^AIWK_DELIVERY_OUTCOME:\s*(CHANGED|ALREADY_SATISFIED)\s*$/gim)];
+  if (matches.length !== 1) return null;
+  return matches[0][1].toUpperCase();
+}
+function resolveDeliveryOutcome({
+  deliveryMode,
+  mutationIntent,
+  changedFiles = [],
+  validationStatus,
+  validationObserved = false,
+  deliveryDecision = null,
+  claimedOutcome = null
+}) {
+  if (deliveryDecision?.startsWith("BLOCK_")) {
+    return "NEEDS_CLARIFICATION";
+  }
+  if (!PASSING_VALIDATION.has(validationStatus)) {
+    return "NOT_DELIVERED";
+  }
+  if (mutationIntent === "readonly") {
+    return "READ_ONLY_RESULT";
+  }
+  if (deliveryMode === "answer-only") {
+    return "PREVIEW_ONLY";
+  }
+  if (changedFiles.length > 0) {
+    if (!validationObserved) return "NOT_DELIVERED";
+    return claimedOutcome === "ALREADY_SATISFIED" ? "NOT_DELIVERED" : "CHANGED";
+  }
+  if (mutationIntent === "write" && claimedOutcome === "ALREADY_SATISFIED" && validationObserved) {
+    return "ALREADY_SATISFIED";
+  }
+  return "NOT_DELIVERED";
+}
+function decideTestAction({
+  executableBehavior,
+  changedFiles = [],
+  addedFiles = [],
+  deletedFiles = [],
+  passingBehaviorTest
+}) {
+  if (!executableBehavior) {
+    return { action: "none", reason: "No executable behavior changed; automated behavior-test changes are not required." };
+  }
+  if (!passingBehaviorTest) {
+    return { action: "none", reason: "Executable behavior changed, but no proportional automated behavior test passed." };
+  }
+  const normalizePath2 = (file) => file.replaceAll("\\", "/");
+  const deleted = new Set(deletedFiles.map(normalizePath2));
+  const added = new Set(addedFiles.map(normalizePath2));
+  const deletedTests = changedFiles.filter((file) => TEST_FILE_PATTERN.test(file) && deleted.has(normalizePath2(file)));
+  const changedTests = changedFiles.filter((file) => TEST_FILE_PATTERN.test(file) && !deleted.has(normalizePath2(file)));
+  if (changedTests.some((file) => added.has(normalizePath2(file)))) {
+    return { action: "add", reason: "A new automated behavior test was added for behavior without relevant existing coverage." };
+  }
+  if (changedTests.length > 0) {
+    return { action: "extend", reason: "Existing automated tests were extended to cover the changed behavior invariant." };
+  }
+  if (deletedTests.length > 0) {
+    return { action: "reuse", reason: "Deleted test files do not count as extended coverage; the remaining automated behavior tests passed." };
+  }
+  return { action: "reuse", reason: "Existing automated behavior tests passed without requiring new test files." };
+}
+
+// src/core/validation/evidence-collector.ts
 var VALIDATION_KINDS = /* @__PURE__ */ new Set(["test", "build", "typecheck", "lint", "security", "smoke", "validate", "other"]);
 function publicStatus(status) {
   if (status === "PASS") return "COMPLETED";
   if (status === "PASS_WITH_NOTES") return "COMPLETED_WITH_NOTES";
   return "BLOCKED";
 }
+function blockingDiagnostic(gate, observed, expected, nextAction) {
+  return `Gate: ${gate}; Observed: ${observed}; Expected: ${expected}; Next action: ${nextAction}`;
+}
 function inferTaskKind(task = {}) {
   const explicit = String(task.kind || "").trim().toLowerCase();
   if (VALIDATION_KINDS.has(explicit)) return explicit;
@@ -408,6 +496,11 @@ var EvidenceCollector = class {
   visualDist;
   port;
   workflowEvidence;
+  claimedOutcome;
+  deliveryChangedFiles;
+  deliveryAddedFiles;
+  deliveryDeletedFiles;
+  riskLevel;
   constructor({
     cwd,
     maxLogLength = 2e3,
@@ -421,7 +514,12 @@ var EvidenceCollector = class {
     explicitApprovals = [],
     visualDist = null,
     port = 8080,
-    workflowEvidence = null
+    workflowEvidence = null,
+    claimedOutcome = null,
+    deliveryChangedFiles = null,
+    deliveryAddedFiles = null,
+    deliveryDeletedFiles = null,
+    riskLevel = null
   }) {
     this.cwd = cwd;
     this.maxLogLength = maxLogLength;
@@ -436,6 +534,11 @@ var EvidenceCollector = class {
     this.visualDist = visualDist;
     this.port = Number(port || 8080);
     this.workflowEvidence = workflowEvidence;
+    this.claimedOutcome = claimedOutcome;
+    this.deliveryChangedFiles = deliveryChangedFiles;
+    this.deliveryAddedFiles = deliveryAddedFiles;
+    this.deliveryDeletedFiles = deliveryDeletedFiles;
+    this.riskLevel = riskLevel || (this.evidencePolicy === "required" ? "high" : "medium");
   }
   async findUserRequest() {
     if (this.userRequest) return this.userRequest;
@@ -473,8 +576,8 @@ var EvidenceCollector = class {
     try {
       const { execSync: execSync2 } = await import("child_process");
       const branch = execSync2("git branch --show-current", { cwd: this.cwd, encoding: "utf8" }).trim();
-      if (branch && branch !== "main" && branch !== "master" && branch.startsWith("feat/")) {
-        return branch.replace("feat/", "").replaceAll("-", " ");
+      if (branch && branch !== "main" && branch !== "master" && /^(feat|fix|docs|chore)\//.test(branch)) {
+        return branch.replace(/^(feat|fix|docs|chore)\//, "").replaceAll("-", " ");
       }
     } catch {
     }
@@ -482,6 +585,29 @@ var EvidenceCollector = class {
   }
   runTask(task) {
     const kind = inferTaskKind(task);
+    if (task.internal === "document-integrity") {
+      const failures = [];
+      for (const file of task.files || []) {
+        try {
+          const content = fsSync.readFileSync(path3.join(this.cwd, file), "utf8");
+          if (!content.trim()) failures.push(`${file}: empty file`);
+          if (/^(<<<<<<<|=======|>>>>>>>)/m.test(content)) failures.push(`${file}: conflict marker`);
+          if (content.split(/\r?\n/).some((line) => /[ \t]+$/.test(line))) failures.push(`${file}: trailing whitespace`);
+        } catch {
+          failures.push(`${file}: unreadable`);
+        }
+      }
+      const status2 = failures.length ? "FAIL" : "PASS";
+      return {
+        name: task.name,
+        command: task.command,
+        kind,
+        status: status2,
+        exitCode: status2 === "PASS" ? 0 : 1,
+        summary: status2 === "PASS" ? "Documentation integrity checks passed." : failures.join("; "),
+        output: failures.join("\n")
+      };
+    }
     if (task.presetStatus) {
       return { name: task.name, command: task.command, kind, status: task.presetStatus, exitCode: null, summary: task.summary || "", output: "" };
     }
@@ -523,15 +649,42 @@ var EvidenceCollector = class {
 ... [TRUNCATED]` : rawOutput;
     return { name: task.name, command: task.command, kind, status, exitCode: result.status, signal: result.signal, summary, output };
   }
+  findAddedFiles(changedFiles) {
+    const added = /* @__PURE__ */ new Set();
+    for (const args of [
+      ["diff", "--cached", "--diff-filter=A", "--name-only"],
+      ["ls-files", "--others", "--exclude-standard"]
+    ]) {
+      const result = spawnSync("git", args, { cwd: this.cwd, encoding: "utf8" });
+      if (result.status !== 0) continue;
+      String(result.stdout || "").split("\n").map((file) => file.trim().replaceAll("\\", "/")).filter(Boolean).forEach((file) => added.add(file));
+    }
+    return changedFiles.filter((file) => added.has(file.replaceAll("\\", "/")));
+  }
   async collect(tasks, { writeArtifact = false } = {}) {
-    const qualityGuard = new QualityGuard({ cwd: this.cwd, taskSlug: this.taskSlug, evidencePolicy: this.evidencePolicy, riskLevel: this.evidencePolicy === "required" ? "high" : "medium", evidenceWillBePersisted: writeArtifact });
-    const implementation = qualityGuard.isImplementationTask();
-    const executableBehavior = await qualityGuard.hasExecutableBehaviorChanges();
+    const qualityGuard = new QualityGuard({
+      cwd: this.cwd,
+      taskSlug: this.taskSlug,
+      evidencePolicy: this.evidencePolicy,
+      riskLevel: this.riskLevel,
+      evidenceWillBePersisted: writeArtifact,
+      scopedChangedFiles: this.deliveryChangedFiles
+    });
+    const implementationFilesPresent = qualityGuard.isImplementationTask();
+    const executableBehavior = await qualityGuard.hasExecutableBehaviorChanges(this.deliveryChangedFiles || void 0);
     const results = tasks.map((task) => this.runTask(task));
     const policyValidation = await qualityGuard.verify();
     const behaviorTests = results.filter((result) => result.kind === "test");
     const passingBehaviorTest = behaviorTests.some((result) => result.status === "PASS");
+    const behaviorTestRequired = executableBehavior && (behaviorTests.length > 0 || this.profile.startsWith("frontend") || qualityGuard.isUiTask());
+    const validationObserved = results.some(
+      (result) => result.kind !== "other" && ["PASS", "PASS_WITH_NOTES"].includes(result.status)
+    );
     const userRequest = await this.findUserRequest();
+    const requestRouter = new RequestRouter({ cwd: this.cwd });
+    const requestUnderstanding = userRequest ? requestRouter.understand(userRequest) : null;
+    const routingDecision = requestUnderstanding ? requestRouter.route(requestUnderstanding) : null;
+    const implementation = requestUnderstanding ? requestUnderstanding.deliveryMode === "workspace" && requestUnderstanding.mutationIntent !== "readonly" : implementationFilesPresent;
     const engine = new DeliveryDecisionEngine({ cwd: this.cwd });
     const projectContext = await engine.detectContext();
     const deliveryDecision = await engine.determineDecision({
@@ -546,16 +699,18 @@ var EvidenceCollector = class {
       explicitApprovals: this.explicitApprovals || []
     });
     const changedFiles = policyValidation.git?.changedFiles || [];
+    const deliveryChangedFiles = this.deliveryChangedFiles || changedFiles;
+    const addedFiles = this.deliveryAddedFiles || this.findAddedFiles(deliveryChangedFiles);
     const artifactFidelityCheck = await fidelityGate.verifyRequestFidelity({
       userRequest,
       deliveryDecision,
       projectContext,
-      changedFiles
+      changedFiles: deliveryChangedFiles
     });
     let overallStatus = "PASS";
-    if (implementation && executableBehavior && tasks.length === 0) overallStatus = "BLOCKED";
-    else if (results.some((result) => ["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(result.status))) overallStatus = "FAIL_QUALITY_GATE";
-    else if (executableBehavior && !passingBehaviorTest) overallStatus = "BLOCKED";
+    if (results.some((result) => ["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(result.status))) overallStatus = "FAIL_QUALITY_GATE";
+    else if (implementation && deliveryChangedFiles.length > 0 && !validationObserved) overallStatus = "BLOCKED";
+    else if (behaviorTestRequired && !passingBehaviorTest) overallStatus = "BLOCKED";
     else if (["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(policyValidation.overallStatus)) overallStatus = "FAIL_QUALITY_GATE";
     else if (results.some((result) => result.status === "PASS_WITH_NOTES") || policyValidation.overallStatus === "PASS_WITH_NOTES") overallStatus = "PASS_WITH_NOTES";
     if (!artifactFidelityCheck || !artifactFidelityCheck.passed) {
@@ -567,14 +722,95 @@ var EvidenceCollector = class {
         overallStatus = "BLOCKED";
       }
     }
+    const testDecision = decideTestAction({
+      executableBehavior,
+      changedFiles: deliveryChangedFiles,
+      addedFiles,
+      deletedFiles: this.deliveryDeletedFiles || [],
+      passingBehaviorTest
+    });
+    const deliveryMode = requestUnderstanding?.deliveryMode || (implementation ? "workspace" : "answer-only");
+    const mutationIntent = requestUnderstanding?.mutationIntent || (implementation ? "write" : "readonly");
+    const deliveryOutcome = resolveDeliveryOutcome({
+      deliveryMode,
+      mutationIntent,
+      changedFiles: deliveryChangedFiles,
+      validationStatus: overallStatus,
+      validationObserved,
+      deliveryDecision: deliveryDecision.decision,
+      claimedOutcome: this.claimedOutcome
+    });
+    if (["NEEDS_CLARIFICATION", "NOT_DELIVERED"].includes(deliveryOutcome) && ["PASS", "PASS_WITH_NOTES"].includes(overallStatus)) {
+      overallStatus = "BLOCKED";
+    }
     const limitations = [];
-    if (implementation && executableBehavior && tasks.length === 0) limitations.push("No meaningful validation command was available for executable implementation work.");
-    if (executableBehavior && behaviorTests.length === 0) {
-      limitations.push("Executable behavior changed without a proportional automated behavior test. Build, lint, typecheck, smoke, screenshots, and manual review do not replace behavior tests.");
+    if (implementation && deliveryChangedFiles.length > 0 && !validationObserved) limitations.push(blockingDiagnostic(
+      "validation",
+      "the requested workspace changed but no meaningful validation result was observed",
+      "at least one proportional validation command must pass after the change",
+      "run the relevant check and finalize again"
+    ));
+    if (implementation && executableBehavior && tasks.length === 0) limitations.push(blockingDiagnostic(
+      "validation-path",
+      "executable implementation work has no available validation command",
+      "the project must provide a proportional syntax, build, or behavior check",
+      "configure or run the smallest relevant validator"
+    ));
+    if (behaviorTestRequired && behaviorTests.length === 0) {
+      limitations.push(blockingDiagnostic(
+        "behavior-test",
+        "UI or test-capable executable behavior changed without an automated behavior test",
+        "a relevant automated behavior test must pass",
+        "run or configure the focused behavior test; build, lint, and screenshots are not substitutes"
+      ));
+    }
+    for (const result of results) {
+      if (["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(result.status)) {
+        limitations.push(blockingDiagnostic(
+          `command:${result.name}`,
+          `${result.summary || result.status} (${result.status})`,
+          `${Array.isArray(result.command) ? result.command.join(" ") : result.command} must exit successfully`,
+          "correct the failure and rerun this command"
+        ));
+      }
     }
     for (const [name, check] of Object.entries(policyValidation.checks || {})) {
       if (check.status === "PASS_WITH_NOTES" && check.reason) limitations.push(`${name}: ${check.reason}`);
+      if (["FAIL", "BLOCKED", "FAIL_QUALITY_GATE"].includes(check.status)) {
+        limitations.push(blockingDiagnostic(
+          `quality:${name}`,
+          check.reason || check.status,
+          `${name} must pass under the active risk/evidence policy`,
+          "satisfy the stated quality requirement and finalize again"
+        ));
+      }
+    }
+    if (!artifactFidelityCheck?.passed) {
+      const detail = artifactFidelityCheck?.reason || artifactFidelityCheck?.violations?.join("; ") || "the observed artifact does not match the requested delivery shape";
+      limitations.push(blockingDiagnostic(
+        "artifact-fidelity",
+        detail,
+        "the delivered artifact must match the requested stack and shape",
+        "correct the artifact or clarify the requested target"
+      ));
+    }
+    if (implementation && (!deliveryDecision?.decision || deliveryDecision.decision.startsWith("BLOCK") || deliveryDecision.decision.includes("BLOCKED") || deliveryDecision.decision === "REQUIRE_EXPLICIT_AUTHORIZATION" || deliveryDecision.decision === "RELEASE_OR_DEPLOY_REQUIRES_APPROVAL")) {
+      limitations.push(blockingDiagnostic(
+        "delivery-decision",
+        deliveryDecision?.reason || deliveryDecision?.decision || "no delivery decision was produced",
+        "the delivery decision must authorize this workspace outcome",
+        "satisfy the stated decision requirement before finalizing"
+      ));
+    }
+    if (["NEEDS_CLARIFICATION", "NOT_DELIVERED"].includes(deliveryOutcome)) {
+      limitations.push(blockingDiagnostic(
+        "delivery-outcome",
+        `the resolved outcome is ${deliveryOutcome}`,
+        "a workspace request requires a scoped change or verified ALREADY_SATISFIED result plus proportional validation",
+        "complete the missing delivery condition or request clarification"
+      ));
     }
+    const uniqueLimitations = [...new Set(limitations)];
     let visualEvidence = null;
     if (this.visualDist) {
       console.log(`
@@ -603,11 +839,18 @@ var EvidenceCollector = class {
       branchRecovery: this.branchRecovery,
       branch: policyValidation.git?.branch || "unknown",
       changedFiles,
+      deliveryChangedFiles,
+      mutationOwner: routingDecision?.mutationOwner || null,
+      capabilitiesUsed: requestUnderstanding?.capabilityRoles || [],
+      deliveryMode,
+      deliveryOutcome,
+      testAction: testDecision.action,
+      testReason: testDecision.reason,
       status: publicStatus(overallStatus),
       internalStatus: overallStatus,
       commands: results,
       checks: policyValidation.checks,
-      limitations,
+      limitations: uniqueLimitations,
       deliveryDecision,
       artifactFidelityCheck,
       visualEvidence,
@@ -627,6 +870,7 @@ var EvidenceCollector = class {
 // src/core/validation/validation-planner.ts
 import fs4 from "fs/promises";
 import path4 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
 var ValidationPlanner = class {
   cwd;
   qualityGuard;
@@ -636,26 +880,80 @@ var ValidationPlanner = class {
     this.qualityGuard = qualityGuard;
     this.stackDetector = new StackDetector({ cwd });
   }
-  async plan(profile = "generic") {
+  async plan(profile = "generic", { requireObservedValidation = false } = {}) {
     const stacks = await this.stackDetector.detect();
     const tasks = [];
-    const changedFiles = this.qualityGuard.getChangedFiles().filter((file) => {
+    const sourceFiles = typeof this.qualityGuard.getScopedChangedFiles === "function" ? this.qualityGuard.getScopedChangedFiles() : this.qualityGuard.getChangedFiles();
+    const changedFiles = sourceFiles.filter((file) => {
       return !/(^|\/)(node_modules|vendor|dist|coverage|\.cache)(\/|$)/.test(String(file).replaceAll("\\", "/"));
     });
     const executableBehavior = await this.qualityGuard.hasExecutableBehaviorChanges();
+    const highRisk = this.qualityGuard.riskLevel === "high";
+    const noChangeVerification = changedFiles.length === 0 && requireObservedValidation && !highRisk;
+    const docsOnly = changedFiles.length > 0 && changedFiles.every(
+      (file) => /(^|\/)(docs?|readme|changelog)(\/|\.|$)|\.(md|txt)$/i.test(file)
+    );
+    if (docsOnly || changedFiles.length === 0 && !highRisk && !requireObservedValidation) return tasks;
+    const uiChanged = changedFiles.some(
+      (file) => /\.(tsx|jsx|vue|html|css|scss|less|blade\.php)$/i.test(file) || /(^|\/)(components|pages|views)\//i.test(file)
+    );
     if (stacks.includes("node")) {
       try {
         const pkg = JSON.parse(await fs4.readFile(path4.join(this.cwd, "package.json"), "utf8"));
         const scripts = pkg.scripts || {};
-        this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
-        this.addNodeScriptTask(tasks, scripts, "test", ["npm", "test"], { rejectNoOp: executableBehavior });
-        this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
-        this.addNodeScriptTask(tasks, scripts, "typecheck", ["npm", "run", "typecheck"]);
-        if (scripts.validate && !String(scripts.validate).includes("ai-workflow collect-evidence")) {
-          this.addNodeScriptTask(tasks, scripts, "validate", ["npm", "run", "validate"]);
-        }
         const hasTs = changedFiles.some((file) => /\.(ts|tsx)$/.test(file)) || await fs4.access(path4.join(this.cwd, "tsconfig.json")).then(() => true).catch(() => false);
-        if (hasTs && !scripts.typecheck) {
+        const addValidate = () => {
+          if (scripts.validate && !String(scripts.validate).includes("ai-workflow collect-evidence")) {
+            this.addNodeScriptTask(tasks, scripts, "validate", ["npm", "run", "validate"]);
+          }
+        };
+        if (noChangeVerification) {
+          if (scripts.test && !this.isNoOpScript(scripts.test)) {
+            this.addNodeScriptTask(tasks, scripts, "test", ["npm", "test"]);
+          } else if (scripts.typecheck) {
+            this.addNodeScriptTask(tasks, scripts, "typecheck", ["npm", "run", "typecheck"]);
+          } else if (scripts.lint) {
+            this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
+          } else if (scripts.build) {
+            this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+          } else {
+            addValidate();
+          }
+        } else if (highRisk) {
+          this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
+          this.addNodeScriptTask(tasks, scripts, "test", ["npm", "test"], { rejectNoOp: executableBehavior });
+          this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+          this.addNodeScriptTask(tasks, scripts, "typecheck", ["npm", "run", "typecheck"]);
+          addValidate();
+        } else if (executableBehavior) {
+          this.addNodeScriptTask(tasks, scripts, "test", ["npm", "test"], { rejectNoOp: true });
+          if (uiChanged) {
+            if (scripts.build) {
+              this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+            } else {
+              tasks.push({
+                name: "build",
+                command: ["npm", "run", "build"],
+                kind: "build",
+                presetStatus: "FAIL_QUALITY_GATE",
+                summary: "Executable UI change requires a configured build script."
+              });
+            }
+          } else if (hasTs) {
+            if (scripts.build) this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+            else this.addNodeScriptTask(tasks, scripts, "typecheck", ["npm", "run", "typecheck"]);
+          }
+        } else if (uiChanged) {
+          if (scripts.build) this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+          else this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
+        } else if (scripts.lint) {
+          this.addNodeScriptTask(tasks, scripts, "lint", ["npm", "run", "lint"]);
+        } else if (scripts.build) {
+          this.addNodeScriptTask(tasks, scripts, "build", ["npm", "run", "build"]);
+        } else {
+          addValidate();
+        }
+        if (hasTs && !scripts.typecheck && !scripts.build && !noChangeVerification) {
           tasks.push({
             name: "typecheck",
             command: ["npm", "run", "typecheck"],
@@ -676,9 +974,10 @@ var ValidationPlanner = class {
           kind: "lint"
         });
       }
-      if (executableBehavior) {
+      if (executableBehavior || changedFiles.length === 0 && requireObservedValidation && tasks.length === 0) {
         const hasPytestConfig = await fs4.access(path4.join(this.cwd, "pytest.ini")).then(() => true).catch(() => false) || await fs4.access(path4.join(this.cwd, "pyproject.toml")).then(() => true).catch(() => false);
-        if (hasPytestConfig || pythonFiles.length > 0) {
+        const pytestAvailable = highRisk && spawnCommandAvailable("pytest", this.cwd);
+        if (hasPytestConfig || pytestAvailable) {
           tasks.push({
             name: "python-test",
             command: ["pytest"],
@@ -698,9 +997,10 @@ var ValidationPlanner = class {
           });
         }
       }
-      if (executableBehavior) {
+      if (executableBehavior || changedFiles.length === 0 && requireObservedValidation && tasks.length === 0) {
         const hasPhpUnitXml = await fs4.access(path4.join(this.cwd, "phpunit.xml")).then(() => true).catch(() => false) || await fs4.access(path4.join(this.cwd, "phpunit.xml.dist")).then(() => true).catch(() => false);
-        if (hasPhpUnitXml || phpFiles.length > 0) {
+        const localPhpUnit = await fs4.access(path4.join(this.cwd, "vendor/bin/phpunit")).then(() => true).catch(() => false);
+        if (hasPhpUnitXml || highRisk && localPhpUnit) {
           tasks.push({
             name: "php-test",
             command: ["vendor/bin/phpunit"],
@@ -732,11 +1032,16 @@ var ValidationPlanner = class {
     return /^(echo\b|true$|exit\s+0$|node\s+-e\s+["']?console\.log)/.test(value) || value.includes("tests-pass");
   }
 };
+function spawnCommandAvailable(command, cwd) {
+  const lookup = process.platform === "win32" ? ["where", [command]] : ["which", [command]];
+  return spawnSync2(lookup[0], lookup[1], { cwd, stdio: "ignore" }).status === 0;
+}
 
 export {
   QualityGuard,
   VisualVerifier,
+  parseDeliveryOutcomeClaim,
   EvidenceCollector,
   ValidationPlanner
 };
-//# sourceMappingURL=chunk-Y4RLP6ZM.js.map
+//# sourceMappingURL=chunk-LD7EHAU2.js.map

package/core/index.d.ts

@@ -1,11 +1,16 @@
+type DeliveryMode = "workspace" | "answer-only";
+
+type MutationOwner = "Astra" | "Phoenix" | "ControlPlane" | null;
 interface RequestUnderstanding {
     rawRequest: string;
     taskGoal: string;
     requestedActor?: string;
     invalidActor?: string;
     requestedCapability?: string;
+    capabilityRoles: string[];
     operationType: string;
     mutationIntent: "readonly" | "write" | "publish";
+    deliveryMode: DeliveryMode;
     riskLevel: "low" | "medium" | "high";
     requiredEvidence: string[];
     safetyConstraints: string[];
@@ -16,8 +21,11 @@ interface RequestUnderstanding {
 interface RoutingDecision {
     requestedActor?: string;
     selectedActor?: string;
+    mutationOwner: MutationOwner;
+    capabilityRoles: string[];
     operationType: string;
     mutationIntent: "readonly" | "write" | "publish";
+    deliveryMode: DeliveryMode;
     permissionDecision: "allowed" | "rerouted" | "blocked";
     reason: string;
     workflowPath: string[];
@@ -176,11 +184,20 @@ interface ExecuteOptions {
     readOnly?: boolean;
     fastTrack?: boolean;
     requireActorConfirmation?: boolean;
+    orchestratedChild?: boolean;
+}
+interface ObservedCommand {
+    command: string;
+    tool: string;
+    status: "PASS" | "FAIL" | "UNKNOWN";
+    exitCode: number | null;
+    source: "sdk" | "json-event" | "text-output";
 }
 interface ExecuteResult {
     success: boolean;
     status?: string;
     commandsRun: string[];
+    commandEvents?: ObservedCommand[];
     eventCount: number;
     error?: string;
     runtimeAgentRequested?: string | null;
@@ -205,7 +222,7 @@ declare class OpenCodeAdapter {
     /**
      * Runs opencode with a prompt and options.
      */
-    execute(message: string, { agent, model, readOnly, fastTrack, requireActorConfirmation }?: ExecuteOptions): Promise<ExecuteResult>;
+    execute(message: string, { agent, model, readOnly, fastTrack, requireActorConfirmation, orchestratedChild }?: ExecuteOptions): Promise<ExecuteResult>;
 }
 
 interface DelegationControllerOptions {
@@ -351,6 +368,8 @@ declare class WorkspaceSnapshot {
     });
     isIgnored(relativePath: string): boolean;
     capture(): Promise<WorkspaceSnapshotData>;
+    listGitVisibleFiles(): string[] | null;
+    scanFiles(relativePaths: string[], filesMap: Record<string, SnapshotFile>): Promise<void>;
     scanDir(dir: string, filesMap: Record<string, SnapshotFile>): Promise<void>;
     calculateHash(snapshot: WorkspaceSnapshotData): string;
 }