@williambeto/ai-workflow 2.4.9 → 2.6.4

package/chunk-UHLZX2EG.js

@@ -0,0 +1,1827 @@
+import {
+  ArtifactFidelityGate,
+  DeliveryDecisionEngine
+} from "./chunk-2AOV2ATY.js";
+
+// src/core/package-assets.ts
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { readFileSync, readdirSync, statSync } from "fs";
+var cachedRoot = null;
+function getPackageRoot() {
+  if (cachedRoot) return cachedRoot;
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const pkgPath = resolve(currentDir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg && typeof pkg === "object" && pkg.name === "@williambeto/ai-workflow") {
+        cachedRoot = currentDir;
+        return cachedRoot;
+      }
+    } catch {
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  throw new Error("Failed to resolve @williambeto/ai-workflow package root physically.");
+}
+function readPackageFile(relativePath) {
+  try {
+    const fullPath = resolve(getPackageRoot(), relativePath);
+    return readFileSync(fullPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function getPackageVersion() {
+  try {
+    const raw = readPackageFile("package.json");
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && typeof parsed.version === "string" ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+function discoverPackageFiles(baseRelativePath) {
+  const files = {};
+  const basePath = resolve(getPackageRoot(), baseRelativePath);
+  try {
+    if (!statSync(basePath).isDirectory()) {
+      return files;
+    }
+  } catch {
+    return files;
+  }
+  function walk(dir, relativePrefix) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = resolve(dir, entry.name);
+      const relativePath = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(fullPath, relativePath);
+      } else if (entry.isFile()) {
+        try {
+          files[relativePath] = readFileSync(fullPath, "utf8");
+        } catch {
+        }
+      }
+    }
+  }
+  walk(basePath, baseRelativePath);
+  return files;
+}
+function getFullSkillFiles(skillName) {
+  const skillRelPath = `dist-assets/skills/${skillName}`;
+  const files = discoverPackageFiles(skillRelPath);
+  return files;
+}
+function getFullAgentContent(agentName) {
+  return readPackageFile(`dist-assets/agents/${agentName}.md`);
+}
+
+// src/core/runtime/opencode-adapter.ts
+import { spawn, spawnSync, execSync } from "child_process";
+import readline from "readline";
+var AGENT_PROMPT_CONTRACTS = {
+  Nexus: "Act as Nexus, the discovery and requirements agent. Stay read-oriented unless the routing contract explicitly permits writes. Produce concrete findings, requirements, and specification inputs.",
+  Orion: "Act as Orion, the planning and release strategy agent. Sequence work through branch safety, proportional validation, and release gates. Do not bypass human authorization.",
+  Astra: "Act as Astra, the implementation agent. Make the minimum scoped code changes needed, preserve unrelated work, and respect branch and validation gates.",
+  Sage: "Act as Sage, the independent validation agent. Audit the implementation against requirements, inspect evidence, and report concrete pass/fail findings.",
+  Phoenix: "Act as Phoenix, the bounded remediation agent. Remediate only concrete findings, keep attempts bounded, and stop when no progress is made."
+};
+var OpenCodeAdapter = class {
+  cwd;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+  /**
+   * Inspects the availability and capability of the OpenCode CLI.
+   */
+  async inspect() {
+    try {
+      const cliHelp = spawnSync("opencode", ["--help"], { encoding: "utf8" });
+      const runHelp = spawnSync("opencode", ["run", "--help"], { encoding: "utf8" });
+      const available = cliHelp.status === 0 && runHelp.status === 0;
+      if (!available) {
+        return {
+          available: false,
+          supports: { run: false, formatJson: false, agent: false, model: false }
+        };
+      }
+      return {
+        available: true,
+        supports: {
+          run: /\brun\b/.test(cliHelp.stdout),
+          formatJson: /--format/.test(runHelp.stdout),
+          agent: /--agent/.test(runHelp.stdout),
+          model: /--model/.test(runHelp.stdout)
+        }
+      };
+    } catch {
+      return {
+        available: false,
+        supports: { run: false, formatJson: false, agent: false, model: false }
+      };
+    }
+  }
+  /**
+   * Runs opencode with a prompt and options.
+   */
+  async execute(message, { agent = null, model = null, readOnly = false, fastTrack = false } = {}) {
+    const inspection = await this.inspect();
+    const isSpecializedAgent = agent && ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(agent);
+    if (!readOnly) {
+      let currentBranch = "";
+      try {
+        currentBranch = execSync("git branch --show-current", { cwd: this.cwd, encoding: "utf8", stdio: "pipe" }).trim();
+      } catch {
+      }
+      const protectedBranches = ["main", "master"];
+      if (protectedBranches.includes(currentBranch)) {
+        if (process.env.AI_WORKFLOW_BYPASS_PROTECTED_BRANCH !== "true") {
+          return {
+            success: false,
+            status: "BLOCKED",
+            error: "FAIL_PROTECTED_BRANCH: Direct writes to protected branch are prohibited.",
+            runtimeAgentRequested: agent,
+            runtimeAgentApplied: null,
+            runtimeAgentSupported: false,
+            runtimeAgentSelectionMode: "unsupported",
+            commandsRun: [],
+            eventCount: 0
+          };
+        }
+      }
+    }
+    if (!inspection.available) {
+      return {
+        success: false,
+        status: isSpecializedAgent ? "BLOCKED" : "FAILED",
+        commandsRun: [],
+        eventCount: 0,
+        error: "OpenCode CLI is not installed or not available in the system PATH.",
+        runtimeAgentRequested: agent || null,
+        runtimeAgentApplied: null,
+        runtimeAgentSupported: false,
+        runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
+      };
+    }
+    const usePromptFallback = Boolean(isSpecializedAgent && !inspection.supports.agent && agent);
+    const runtimeMessage = usePromptFallback ? `${AGENT_PROMPT_CONTRACTS[agent]}
+
+Runtime agent selection note: requested actor '${agent}' could not be applied with --agent because this OpenCode runtime does not support it. Continue as that actor by prompt contract and preserve all AI Workflow Kit safety rules.
+
+User request:
+${message}` : message;
+    const runtimeAgentSelectionMode = isSpecializedAgent ? usePromptFallback ? "prompt-fallback" : "explicit" : "default";
+    const runInWorkspace = async (targetCwd) => {
+      return new Promise((resolve2) => {
+        const args = ["run", runtimeMessage];
+        if (inspection.supports.formatJson) {
+          args.push("--format", "json");
+        }
+        if (isSpecializedAgent && inspection.supports.agent && agent) {
+          args.push("--agent", agent);
+        }
+        if (model && inspection.supports.model) {
+          args.push("--model", model);
+        }
+        console.log(`[RUNTIME] Delegating to OpenCode: opencode ${args.map((a) => a.includes(" ") ? `"${a}"` : a).join(" ")}`);
+        const child = spawn("opencode", args, {
+          cwd: targetCwd,
+          stdio: ["ignore", "pipe", "inherit"]
+          // Inherit stderr to show warnings directly
+        });
+        const rl = readline.createInterface({
+          input: child.stdout,
+          terminal: false
+        });
+        const commandsRun = [];
+        let eventCount = 0;
+        rl.on("line", (line) => {
+          const trimmed = line.trim();
+          if (!trimmed) return;
+          try {
+            const event = JSON.parse(trimmed);
+            eventCount++;
+            if (event.type === "text" && event.part?.text) {
+              process.stdout.write(event.part.text);
+            }
+            if (event.type === "step_start" && event.part?.toolCalls) {
+              for (const call of event.part.toolCalls) {
+                if (call.name === "run_command" && call.args?.CommandLine) {
+                  commandsRun.push(call.args.CommandLine);
+                }
+                if (readOnly) {
+                  const name = call.name || "";
+                  const isWriteTool = name.startsWith("write_") || name.includes("write") || name.includes("replace") || name.includes("edit") || name.includes("delete") || name.includes("remove");
+                  let isDestructiveGit = false;
+                  if (name === "run_command" && call.args?.CommandLine) {
+                    const cmd = call.args.CommandLine;
+                    const destPattern = /\b(git\s+(commit|add|push|merge|reset|rm|branch|checkout|switch|stash|init)|touch|rm|mkdir|cp|mv|chmod|chown|tee|sed|awk)\b|>>|>/;
+                    if (destPattern.test(cmd)) {
+                      isDestructiveGit = true;
+                    }
+                  }
+                  if (isWriteTool || isDestructiveGit) {
+                    console.error(`
+[SECURITY WARNING] Read-only execution blocked attempt to write/modify workspace: tool '${name}' or command detected.`);
+                    child.kill();
+                    resolve2({
+                      success: false,
+                      commandsRun,
+                      eventCount,
+                      error: `Read-only confinement violation: tool '${name}' or command attempted write/modify operation during read-only task.`,
+                      runtimeAgentRequested: agent || null,
+                      runtimeAgentApplied: usePromptFallback ? null : null,
+                      runtimeAgentSupported: inspection.supports.agent,
+                      runtimeAgentSelectionMode
+                    });
+                    return;
+                  }
+                }
+              }
+            }
+          } catch {
+            console.log(trimmed);
+          }
+        });
+        child.on("close", (code) => {
+          console.log("\n[RUNTIME] OpenCode finished execution.");
+          resolve2({
+            success: code === 0,
+            commandsRun,
+            eventCount,
+            runtimeAgentRequested: agent || null,
+            runtimeAgentApplied: isSpecializedAgent && !usePromptFallback ? agent : null,
+            runtimeAgentSupported: inspection.supports.agent,
+            runtimeAgentSelectionMode
+          });
+        });
+        child.on("error", (err) => {
+          console.error(`
+[RUNTIME] Failed to launch opencode: ${err.message}`);
+          resolve2({
+            success: false,
+            commandsRun,
+            eventCount: 0,
+            error: err.message,
+            runtimeAgentRequested: agent || null,
+            runtimeAgentApplied: null,
+            runtimeAgentSupported: inspection.supports.agent,
+            runtimeAgentSelectionMode
+          });
+        });
+      });
+    };
+    if (readOnly && !fastTrack) {
+      const { runInReadOnlyWorkspace } = await import("./read-only-workspace-PZBE7KAX.js");
+      return runInReadOnlyWorkspace(this.cwd, runInWorkspace);
+    } else {
+      return runInWorkspace(this.cwd);
+    }
+  }
+};
+
+// src/core/gates/branch-gate.ts
+import { execSync as execSync2 } from "child_process";
+import fs from "fs";
+import path from "path";
+function slugify(value = "task") {
+  return String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "task";
+}
+var BranchGate = class {
+  protectedBranches;
+  logPath;
+  cwd;
+  constructor({ protectedBranches = ["main", "master"], memoryDir, cwd = process.cwd() } = {}) {
+    this.protectedBranches = protectedBranches;
+    this.logPath = memoryDir ? path.join(memoryDir, "GATE_ALERTS.log") : null;
+    this.cwd = cwd;
+  }
+  run(command) {
+    return execSync2(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+  log(event) {
+    if (!this.logPath) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${event}
+`;
+    try {
+      if (!fs.existsSync(path.dirname(this.logPath))) fs.mkdirSync(path.dirname(this.logPath), { recursive: true });
+      fs.appendFileSync(this.logPath, logEntry);
+    } catch (error) {
+      console.error(`Failed to write to gate log: ${error.message}`);
+    }
+  }
+  getDirtyState() {
+    const lines = this.run("git status --short").split("\n").filter(Boolean);
+    const tracked = lines.filter((line) => !line.startsWith("??"));
+    const untracked = lines.filter((line) => line.startsWith("??"));
+    return { clean: lines.length === 0, tracked, untracked, lines };
+  }
+  createScopedBranch(taskSlug) {
+    const base = `feat/${slugify(taskSlug)}`;
+    let candidate = base;
+    let suffix = 2;
+    while (true) {
+      try {
+        this.run(`git show-ref --verify --quiet refs/heads/${candidate}`);
+        candidate = `${base}-${suffix++}`;
+      } catch {
+        break;
+      }
+    }
+    this.run(`git switch -c ${candidate}`);
+    return candidate;
+  }
+  getCurrentBranch() {
+    try {
+      return this.run("git branch --show-current") || this.run("git symbolic-ref --short HEAD") || "unknown";
+    } catch {
+      try {
+        return this.run("git symbolic-ref --short HEAD") || "unknown";
+      } catch {
+        return "unknown";
+      }
+    }
+  }
+  /**
+   * Strictly verifies branch safety without any override bypasses.
+   */
+  check(overrideIgnored = "", { taskSlug = "implementation", readOnly = false } = {}) {
+    if (readOnly) {
+      const currentBranch = this.getCurrentBranch();
+      return { blocked: false, branch: currentBranch, recovered: false, readOnly: true };
+    }
+    try {
+      try {
+        this.run("git rev-parse --is-inside-work-tree");
+      } catch (e) {
+        const reason = "Git is unavailable or not inside a Git repository. Implementation work is blocked.";
+        this.log(`BLOCKED: ${reason}`);
+        return { blocked: true, branch: "unknown", reason };
+      }
+      const currentBranch = this.getCurrentBranch();
+      if (!currentBranch || currentBranch === "unknown" || currentBranch.trim() === "") {
+        const reason = "Could not determine current Git branch name. Implementation work is blocked.";
+        this.log(`BLOCKED: ${reason}`);
+        return { blocked: true, branch: "unknown", reason };
+      }
+      const isProtected = this.protectedBranches.includes(currentBranch);
+      if (!isProtected) {
+        return { blocked: false, branch: currentBranch, recovered: false };
+      }
+      const dirty = this.getDirtyState();
+      if (!dirty.clean) {
+        const reason = `Direct writes to protected branch '${currentBranch}' are prohibited and the branch is dirty (has changes).`;
+        this.log(`BLOCKED: ${reason}`);
+        return { blocked: true, branch: currentBranch, reason, dirtyState: dirty };
+      }
+      const recoveredBranch = this.createScopedBranch(taskSlug);
+      this.log(`AUTO-RECOVERED '${currentBranch}' -> '${recoveredBranch}'`);
+      return {
+        blocked: false,
+        branch: recoveredBranch,
+        branchBefore: currentBranch,
+        recovered: true,
+        dirtyState: dirty
+      };
+    } catch (error) {
+      const reason = `Git command failure on branch gate check: ${error.message}`;
+      this.log(`BLOCKED: ${reason}`);
+      return { blocked: true, branch: "unknown", error: error.message, reason, recovered: false };
+    }
+  }
+};
+
+// src/core/sdd/validator.ts
+import fs2 from "fs/promises";
+var SpecValidator = class {
+  /**
+   * Validates a specification file.
+   */
+  async validate(filePath) {
+    try {
+      const content = await fs2.readFile(filePath, "utf8");
+      let tier = "unknown";
+      if (content.includes("[DEEP]")) tier = "deep";
+      else if (content.includes("[STANDARD]")) tier = "standard";
+      else if (content.includes("[TINY]")) tier = "tiny";
+      if (tier === "unknown") {
+        return { valid: false, reason: "Specification tier [DEEP|STANDARD|TINY] not identified in title." };
+      }
+      if (!content.includes("## Metadata")) {
+        return { valid: false, reason: "Missing '## Metadata' section.", tier };
+      }
+      if (!content.includes("## Acceptance Criteria")) {
+        return { valid: false, reason: "Missing '## Acceptance Criteria' section.", tier };
+      }
+      const lines = content.split("\n");
+      const statusLine = lines.find((l) => l.includes("Status:"));
+      if (!statusLine) {
+        return { valid: false, reason: "Missing Status field in Metadata section.", tier };
+      }
+      const statusPart = statusLine.split(":")[1].replace(/[\*_]/g, "").trim().toUpperCase();
+      if (statusPart.includes("|")) {
+        return { valid: false, reason: "Specification status is a template list. Must be explicitly set to 'APPROVED'.", tier };
+      }
+      if (statusPart !== "APPROVED") {
+        return { valid: false, reason: `Specification status is '${statusPart}', but must be 'APPROVED' to proceed.`, tier };
+      }
+      return { valid: true, tier };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { valid: false, reason: `Specification file not found: ${filePath}` };
+      }
+      return { valid: false, reason: `Error reading specification: ${error.message}` };
+    }
+  }
+};
+
+// src/core/handoff/handoff-engine.ts
+import { execSync as execSync3 } from "child_process";
+import fs3 from "fs/promises";
+import path2 from "path";
+var HandoffEngine = class {
+  cwd;
+  constructor({ cwd }) {
+    this.cwd = cwd;
+  }
+  /**
+   * Generates a handoff packet.
+   */
+  async generate({ taskId, author, status, specPaths = [], nextActions, evidence = null }) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let specsContent = "";
+    for (const specPath of specPaths) {
+      const absolutePath = path2.isAbsolute(specPath) ? specPath : path2.join(this.cwd, specPath);
+      try {
+        const content = await fs3.readFile(absolutePath, "utf8");
+        specsContent += `### File: ${specPath}
+
+${content}
+
+`;
+      } catch (err) {
+        specsContent += `### File: ${specPath}
+
+[Error reading file: ${err.message}]
+
+`;
+      }
+    }
+    let gitDiff = "No changes detected.";
+    try {
+      gitDiff = execSync3("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "No changes detected.";
+    } catch (err) {
+      gitDiff = `[Error capturing diff: ${err.message}]`;
+    }
+    let evidenceJson = "{}";
+    let evidenceSummary = "No evidence found.";
+    if (evidence) {
+      const data = typeof evidence === "string" ? JSON.parse(evidence) : evidence;
+      evidenceJson = JSON.stringify(data, null, 2);
+      evidenceSummary = `Status: ${data.status || data.internalStatus || "unknown"}, Commands: ${data.commands?.length || 0}`;
+    } else {
+      const evidencePath = path2.join(this.cwd, "EVIDENCE.json");
+      try {
+        const content = await fs3.readFile(evidencePath, "utf8");
+        const data = JSON.parse(content);
+        evidenceJson = JSON.stringify(data, null, 2);
+        evidenceSummary = `Status: ${data.status}, Commands: ${data.commands?.length || 0}`;
+      } catch (err) {
+      }
+    }
+    const possibleTemplatePaths = [
+      path2.join(this.cwd, ".ai-workflow/templates/HANDOFF.template.md"),
+      path2.join(this.cwd, ".ai-workflow/harness/handoffs/HANDOFF.template.md"),
+      path2.join(getPackageRoot(), "dist-assets/templates/HANDOFF.template.md"),
+      path2.join(getPackageRoot(), "dist-assets/harness/handoffs/HANDOFF.template.md")
+    ];
+    let template = null;
+    let lastError = null;
+    for (const tPath of possibleTemplatePaths) {
+      try {
+        template = await fs3.readFile(tPath, "utf8");
+        break;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    if (!template) {
+      throw new Error(`CRITICAL FAILURE: Could not locate HANDOFF.template.md. Tried paths:
+${possibleTemplatePaths.join("\n")}
+Last error: ${lastError?.message}`);
+    }
+    const packet = template.replace("${TASK_ID}", taskId || "unknown").replace("${TIMESTAMP}", timestamp).replace("${AUTHOR}", author || "AI Workflow Kit").replace("${STATUS}", status || "IN_PROGRESS").replace("${SPECS_CONTENT}", specsContent || "No specs provided.").replace("${EVIDENCE_SUMMARY}", evidenceSummary).replace("${EVIDENCE_JSON}", evidenceJson).replace("${GIT_DIFF}", gitDiff).replace("${NEXT_ACTIONS}", nextActions || "Awaiting manager assignment.");
+    const handoffDir = path2.join(this.cwd, ".ai-workflow/handoffs");
+    await fs3.mkdir(handoffDir, { recursive: true });
+    const packetName = `HANDOFF-${taskId || "TMP"}-${Date.now()}.md`;
+    const packetPath = path2.join(handoffDir, packetName);
+    await fs3.writeFile(packetPath, packet);
+    return packetPath;
+  }
+};
+
+// src/core/healing/healer-engine.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+import crypto from "crypto";
+
+// src/core/statuses.ts
+var COMPLETION_STATUSES = Object.freeze([
+  "PASS",
+  "PASS_WITH_NOTES",
+  "FAIL_DELEGATION_GATE",
+  "FAIL_QUALITY_GATE",
+  "FAIL",
+  "BLOCKED",
+  "NOT_RUN"
+]);
+var RECOVERABLE_GATE_STATUSES = Object.freeze([
+  "FAIL_DELEGATION_GATE",
+  "FAIL_QUALITY_GATE"
+]);
+var TERMINAL_FAILURE_STATUSES = Object.freeze([
+  "FAIL",
+  "BLOCKED"
+]);
+function isRecoverableGateFailure(status) {
+  return RECOVERABLE_GATE_STATUSES.includes(status);
+}
+function isTerminalFailure(status) {
+  return TERMINAL_FAILURE_STATUSES.includes(status);
+}
+var COMPLETION_STATUS_TEXT = COMPLETION_STATUSES.join(" | ");
+
+// src/core/healing/healer-engine.ts
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function collectBlockingFindings(result = {}) {
+  const findings = [];
+  const add = (source, value) => {
+    if (!value || typeof value !== "object") return;
+    const status = value.status || value.overallStatus;
+    if (!["FAIL", "FAIL_QUALITY_GATE", "FAIL_DELEGATION_GATE", "BLOCKED"].includes(status)) return;
+    findings.push({
+      source,
+      status,
+      missing: Array.isArray(value.missing) ? [...value.missing].sort() : [],
+      reason: value.reason || value.summary || ""
+    });
+  };
+  add("result", result);
+  add("evidence", result.evidence);
+  add("quality", result.quality);
+  const checks = result.quality?.checks || result.policyValidation?.checks || result.checks || {};
+  for (const [name, check] of Object.entries(checks)) add(`check:${name}`, check);
+  return findings.sort((a, b) => a.source.localeCompare(b.source));
+}
+var HealerEngine = class {
+  cwd;
+  /** @deprecated use remediationLimit instead */
+  mode;
+  taskSlug;
+  maxAttempts;
+  ledger;
+  constructor({ cwd, mode, taskSlug = "implementation", maxAttempts = null, remediationLimit = null, ledger = null }) {
+    this.cwd = cwd;
+    this.taskSlug = taskSlug;
+    const legacyLimit = mode === "full" ? 3 : mode === "quick" ? 1 : mode === "standard" ? 2 : null;
+    this.maxAttempts = remediationLimit ?? maxAttempts ?? legacyLimit ?? 2;
+    this.mode = this.maxAttempts === 3 ? "full" : this.maxAttempts === 1 ? "quick" : "standard";
+    this.ledger = ledger;
+  }
+  get statePath() {
+    return path3.join(this.cwd, ".ai-workflow", `healing-state-${this.taskSlug}.json`);
+  }
+  fingerprint(result) {
+    return crypto.createHash("sha256").update(stableJson(collectBlockingFindings(result))).digest("hex");
+  }
+  blockingCount(result) {
+    return collectBlockingFindings(result).length;
+  }
+  affectedChecks(result) {
+    return collectBlockingFindings(result).map((finding) => finding.source);
+  }
+  hasProgress(before, after, remediation = {}) {
+    if (!isRecoverableGateFailure(after.overallStatus)) return true;
+    const beforeCount = this.blockingCount(before);
+    const afterCount = this.blockingCount(after);
+    if (afterCount < beforeCount) return true;
+    if (this.fingerprint(before) !== this.fingerprint(after) && (remediation.changedFiles?.length || remediation.evidenceAdded?.length)) return true;
+    return false;
+  }
+  async writeState(state) {
+    await fs4.mkdir(path3.dirname(this.statePath), { recursive: true });
+    await fs4.writeFile(this.statePath, JSON.stringify(state, null, 2));
+  }
+  async resetState() {
+    try {
+      await fs4.unlink(this.statePath);
+    } catch {
+    }
+  }
+  async writeRemediationRequest({ attempt, result }) {
+    const requestPath = path3.join(this.cwd, ".ai-workflow", "remediation-request.json");
+    await fs4.mkdir(path3.dirname(requestPath), { recursive: true });
+    const request = {
+      taskSlug: this.taskSlug,
+      executionMode: this.mode,
+      attempt,
+      maxAttempts: this.maxAttempts,
+      status: result.overallStatus,
+      affectedChecks: this.affectedChecks(result),
+      findingsFingerprint: this.fingerprint(result),
+      instruction: "Apply the smallest safe correction for the listed gates, then rerun validation. Do not broaden scope."
+    };
+    await fs4.writeFile(requestPath, JSON.stringify(request, null, 2));
+    return requestPath;
+  }
+  async run({
+    initialResult,
+    validate,
+    remediate
+  }) {
+    let current = initialResult;
+    const history = [];
+    const seen = /* @__PURE__ */ new Set();
+    if (!isRecoverableGateFailure(current.overallStatus)) {
+      await this.resetState();
+      return { ...current, remediation: { status: "NOT_REQUIRED", attempts: 0, history } };
+    }
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      const fingerprint = this.fingerprint(current);
+      if (seen.has(fingerprint)) {
+        const blocked = { overallStatus: "BLOCKED", reason: "Repeated unresolved finding", previousResult: current };
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt - 1, history });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt - 1, history } };
+      }
+      seen.add(fingerprint);
+      const requestPath = await this.writeRemediationRequest({ attempt, result: current });
+      if (typeof remediate !== "function") {
+        const blocked = { overallStatus: "BLOCKED", reason: "No remediation executor available", previousResult: current, requestPath };
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt - 1, history, requestPath });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt - 1, history, requestPath } };
+      }
+      const remediation = await remediate({
+        attempt,
+        maxAttempts: this.maxAttempts,
+        mode: this.mode,
+        taskSlug: this.taskSlug,
+        result: current,
+        affectedChecks: this.affectedChecks(current),
+        requestPath
+      });
+      if (!remediation?.applied) {
+        const blocked = { overallStatus: "BLOCKED", reason: remediation?.reason || "Remediation was not applied", previousResult: current, requestPath };
+        history.push({ attempt, before: current.overallStatus, remediation, after: "NOT_RUN", progress: false });
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt, history });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt, history } };
+      }
+      const next = await validate({ affectedChecks: this.affectedChecks(current), attempt });
+      const progress = this.hasProgress(current, next, remediation);
+      const findingsConcrete = this.affectedChecks(current).length > 0;
+      const hashAltered = remediation.changedFiles && remediation.changedFiles.length > 0;
+      const inScope = hashAltered && remediation.changedFiles.every((file) => {
+        const norm = file.replaceAll("\\", "/");
+        if (norm.startsWith(".ai-workflow/")) return false;
+        if (norm === "package.json" || norm === "package-lock.json" || norm === "tsconfig.json" || norm === ".gitignore" || norm === "opencode.jsonc" || norm === "EVIDENCE.json") {
+          return false;
+        }
+        return true;
+      });
+      const validationPassed = next.overallStatus === "PASS" || next.overallStatus === "PASS_WITH_NOTES";
+      const phoenixSuccessful = findingsConcrete && hashAltered && inScope && validationPassed;
+      if (this.ledger && phoenixSuccessful) {
+        this.ledger.logEvent({
+          actor: "Phoenix",
+          actorType: "runtime-agent",
+          observed: true,
+          runtime: "opencode",
+          eventType: "remediation_complete",
+          provenance: "opencode-adapter",
+          data: {
+            success: true,
+            changedFiles: remediation.changedFiles,
+            event: "remediation.completed"
+          }
+        });
+      }
+      history.push({
+        attempt,
+        before: current.overallStatus,
+        after: next.overallStatus,
+        progress,
+        changedFiles: remediation.changedFiles || [],
+        evidenceAdded: remediation.evidenceAdded || [],
+        affectedChecks: this.affectedChecks(current)
+      });
+      await this.writeState({ status: next.overallStatus, attempts: attempt, history });
+      if (!isRecoverableGateFailure(next.overallStatus)) {
+        await this.resetState();
+        return { ...next, remediation: { status: "RESOLVED", attempts: attempt, history } };
+      }
+      if (!progress) {
+        return {
+          overallStatus: "BLOCKED",
+          reason: "Remediation made no measurable progress",
+          previousResult: next,
+          remediation: { status: "BLOCKED", attempts: attempt, history }
+        };
+      }
+      current = next;
+    }
+    return {
+      overallStatus: "BLOCKED",
+      reason: `Quality remediation attempts exhausted (limit: ${this.maxAttempts})`,
+      previousResult: current,
+      remediation: { status: "BLOCKED", attempts: this.maxAttempts, history }
+    };
+  }
+};
+
+// src/core/workflow-profiles.ts
+var PROFILE_DEFINITIONS = Object.freeze({
+  "frontend-product": Object.freeze({
+    owner: "Astra",
+    skills: ["frontend-development", "ui-ux-design", "frontend-design-system"],
+    objective: "Deliver a user-facing product or marketing surface with truthful copy and deliberate visual composition.",
+    requiredChecks: ["tests", "typecheck", "build", "responsive-render", "primary-interaction", "truthfulness"],
+    forbiddenAssumptions: ["fixed SaaS section sequence", "mandatory pricing", "mandatory testimonials", "subjective premium score"]
+  }),
+  "frontend-utility": Object.freeze({
+    owner: "Astra",
+    skills: ["frontend-development", "ui-ux-design", "frontend-design-system"],
+    objective: "Deliver a focused user tool with a complete primary flow and clear operational states.",
+    requiredChecks: ["tests", "typecheck", "build", "responsive-render", "primary-interaction"],
+    forbiddenAssumptions: ["marketing sections", "pricing", "testimonials", "commercial narrative"]
+  }),
+  "backend-api": Object.freeze({
+    owner: "Astra",
+    skills: ["backend-development"],
+    objective: "Deliver a bounded backend/API change with validated contracts, errors, authorization, and tests.",
+    requiredChecks: ["tests", "build-or-typecheck", "input-validation", "failure-paths"],
+    forbiddenAssumptions: ["frontend deliverables", "visual evidence"]
+  }),
+  refactor: Object.freeze({
+    owner: "Astra",
+    skills: ["refactoring"],
+    objective: "Improve structure without changing observable behavior outside the approved scope.",
+    requiredChecks: ["behavior-preservation", "tests", "focused-diff"],
+    forbiddenAssumptions: ["new product behavior", "unrelated cleanup"]
+  }),
+  documentation: Object.freeze({
+    owner: "Astra",
+    skills: ["documentation"],
+    objective: "Create or update accurate documentation grounded in the current repository behavior.",
+    requiredChecks: ["references", "paths", "commands", "consistency"],
+    forbiddenAssumptions: ["implementation claims without evidence"]
+  }),
+  "security-review": Object.freeze({
+    owner: "Sage",
+    skills: ["qa-workflow", "technical-leadership"],
+    objective: "Inspect security-relevant behavior and report evidence-ranked findings without implementing unrelated changes.",
+    requiredChecks: ["evidence", "severity", "runtime-vs-dev", "remediation-owner"],
+    forbiddenAssumptions: ["automatic force fixes", "unverified exploitability"]
+  }),
+  generic: Object.freeze({
+    owner: "Atlas",
+    skills: [],
+    objective: "Route work without inventing domain requirements.",
+    requiredChecks: ["scope", "owner", "mode"],
+    forbiddenAssumptions: ["domain-specific structure"]
+  })
+});
+var PROFILE_PATTERNS = Object.freeze([
+  ["security-review", /\b(?:security review|security audit|vulnerability audit|threat model)\b/i],
+  ["refactor", /\b(?:refactor|restructure|cleanup without behavior change|preserve behavior)\b/i],
+  ["documentation", /\b(?:documentation only|write docs|update readme|document the|documentation task)\b/i],
+  ["backend-api", /\b(?:api endpoint|backend api|rest api|graphql|controller|service endpoint|authenticated api)\b/i],
+  ["frontend-product", /\b(?:landing page|marketing page|product page|pricing page|homepage|redesign|brand page)\b/i],
+  ["frontend-utility", /\b(?:validator|search page|lookup|dashboard|form|calculator|tool|admin page|repository search)\b/i]
+]);
+function getWorkflowProfile(name = "generic") {
+  return PROFILE_DEFINITIONS[name] || PROFILE_DEFINITIONS.generic;
+}
+function resolveWorkflowProfile({ request = "", explicitProfile = null } = {}) {
+  if (explicitProfile && PROFILE_DEFINITIONS[explicitProfile]) return explicitProfile;
+  const text = String(request).trim();
+  for (const [profile, pattern] of PROFILE_PATTERNS) {
+    if (pattern.test(text)) return profile;
+  }
+  return "generic";
+}
+
+// src/core/request-router.ts
+import path4 from "path";
+import fs5 from "fs";
+var RequestRouter = class {
+  cwd;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+  /**
+   * Understands and classifies a natural language request.
+   */
+  understand(request) {
+    const text = String(request).trim();
+    if (!text) {
+      throw new Error("Cannot classify an empty request.");
+    }
+    const { operationType, requestedCapability } = this.extractCapability(text);
+    const mutationIntent = this.determineMutationIntent(text, operationType);
+    const riskAssessment = this.determineRiskAssessment(text, mutationIntent);
+    const riskLevel = riskAssessment.riskLevel;
+    const { safetyConstraints, requiredEvidence } = this.determineSafetyAndEvidence(text, mutationIntent);
+    return {
+      rawRequest: text,
+      taskGoal: `Perform ${operationType} operation under ${mutationIntent} intent`,
+      requestedActor: void 0,
+      invalidActor: void 0,
+      requestedCapability,
+      operationType,
+      mutationIntent,
+      riskLevel,
+      requiredEvidence,
+      safetyConstraints,
+      specPolicy: riskAssessment.specPolicy,
+      matchedSignals: riskAssessment.matchedSignals,
+      riskDrivers: riskAssessment.riskDrivers
+    };
+  }
+  extractCapability(text) {
+    let operationType = "explain";
+    let requestedCapability = void 0;
+    const capabilityMappings = [
+      { op: "discover", pattern: /\b(discover|inspect|map|scan|structure|architecture|repo|search|find)\b/i },
+      { op: "validate", pattern: /\b(validate|audit|review|check|verify|test)\b/i },
+      { op: "implement", pattern: /\b(implement|implementa|build|create|crie|cria|add|develop|write|change|modify|atualiza|atualizar|refatora|refatorar)\b/i },
+      { op: "fix", pattern: /\b(fix|repair|correct|corrige|corrigir|heal|solve|remediate)\b/i },
+      { op: "release", pattern: /\b(release|tag|prepare release|prepara(?:r)?\s+(?:a\s+)?release)\b/i },
+      { op: "deploy", pattern: /\b(deploy|publish|push|produção|producao)\b/i }
+    ];
+    for (const mapping of capabilityMappings) {
+      const match = text.match(mapping.pattern);
+      if (match) {
+        operationType = mapping.op;
+        requestedCapability = match[1];
+        break;
+      }
+    }
+    return { operationType, requestedCapability };
+  }
+  determineMutationIntent(text, operationType) {
+    const writePatterns = /\b(implement|implementa|build|fix|corrige|write|change|modify|create|crie|cria|add|refactor|refatora|refatorar|update|atualiza|atualizar)\b/i;
+    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify|validate|discover|map)\b/i;
+    let mutationIntent = "write";
+    if (/\b(read-only|readonly)\b/i.test(text)) {
+      mutationIntent = "readonly";
+    } else if (writePatterns.test(text)) {
+      mutationIntent = "write";
+    } else if (readOnlyPatterns.test(text) || ["discover", "validate"].includes(operationType)) {
+      mutationIntent = "readonly";
+    }
+    if (/\b(publish|release|deploy|produção|producao|push to npm|push to remote)\b/i.test(text)) {
+      mutationIntent = "publish";
+    }
+    return mutationIntent;
+  }
+  determineRiskAssessment(text, mutationIntent) {
+    const matchedSignals = [];
+    const add = (signal, pattern) => {
+      if (pattern.test(text)) {
+        matchedSignals.push(signal);
+        return true;
+      }
+      return false;
+    };
+    const taskTypeSignals = {
+      docsCopy: add("task:docs-copy", /\b(README|docs?|documenta[cç][aã]o|typo|copy|frase|comment|coment[áa]rio)\b/i),
+      refactor: add("task:refactor", /\b(refactor|refatora|refatorar|simplificar|mais simples de manter|manuten[cç][aã]o)\b/i),
+      noBehaviorChange: add("scope:no-behavior-change", /\b(sem alterar (?:o )?comportamento|without changing behavior|without behaviour change|no behavior change|comportamento existente)\b/i),
+      landingPage: add("task:landing-page", /\b(landing page|hotsite|p[áa]gina de venda|p[áa]gina comercial)\b/i),
+      dashboard: add("task:dashboard", /\b(dashboard|painel)\b/i),
+      bugfix: add("task:bugfix", /\b(bug|fix|corrige|corrigir|erro|falha|n[aã]o envia|não envia)\b/i),
+      release: add("task:release", /\b(release|deploy|produ[cç][aã]o|publish|publicar|lan[cç]amento)\b/i)
+    };
+    const domainRiskSignals = {
+      adult: add("domain:adult", /\b(er[óo]tic[oa]s?|adult[oa]s?|sexual|sexo|porn(?:o|ografia)?|18\+)\b/i),
+      auth: add("domain:auth", /\b(login|auth|autentica[cç][aã]o|autoriza[cç][aã]o|permiss(?:ão|oes|ões)|admin|administrador|roles?|rbac)\b/i),
+      payment: add("domain:payment", /\b(pagamento|checkout|billing|cobran[cç]a|fatura[cç][aã]o|assinatura|cart[aã]o|stripe|paypal)\b/i),
+      securityGovernance: add("domain:security-governance", /\b(SECURITY\.md|seguran[cç]a|security policy|pol[ií]tica de seguran[cç]a|governance|governan[cç]a|compliance|branch safety)\b/i)
+    };
+    const impactSignals = {
+      personalData: add("impact:personal-data", /\b(leads?|dados pessoais|personal data|crm|contatos?|contactos?|clientes?|exporta[cç][aã]o|exportar|armazenamento|armazenar|integra[cç][aã]o|integrar)\b/i),
+      productionRelease: mutationIntent === "publish" || add("impact:production-release", /\b(produ[cç][aã]o|release|deploy|publish|publicar|npm)\b/i),
+      adminPermissions: add("impact:admin-permissions", /\b(admin|administrador|permiss(?:ão|oes|ões)|roles?|rbac)\b/i)
+    };
+    if (mutationIntent === "publish" && !matchedSignals.includes("impact:production-release")) {
+      matchedSignals.push("impact:production-release");
+    }
+    const scopeSignals = {
+      localized: add("scope:localized", /\b(localizado|uma frase|typo|pequeno|small|tiny|simples|README)\b/i),
+      broad: add("scope:broad", /\b(plataforma|sistema|completo|premium|end-to-end|amplo|v[aá]rias|m[úu]ltiplas|empresa)\b/i),
+      architectural: add("scope:architectural", /\b(deep|architectural|arquitetural|migration|migra[cç][aã]o|major|full|\[deep\])\b/i),
+      explicitHigh: add("scope:explicit-high", /\b(high-risk|high risk|alto risco)\b/i),
+      explicitRequiredSpec: add("scope:explicit-required-spec", /\b(formal spec|required spec|especifica[cç][aã]o formal)\b/i),
+      explicitRequiredEvidence: add("scope:explicit-required-evidence", /\b(required evidence|evidence required|evid[eê]ncia obrigat[óo]ria)\b/i)
+    };
+    let riskLevel = "medium";
+    const riskDrivers = [];
+    const highDrivers = [
+      ["scope:explicit-high", scopeSignals.explicitHigh],
+      ["scope:architectural", scopeSignals.architectural],
+      ["domain:adult", domainRiskSignals.adult],
+      ["domain:auth", domainRiskSignals.auth],
+      ["domain:payment", domainRiskSignals.payment],
+      ["domain:security-governance", domainRiskSignals.securityGovernance],
+      ["impact:production-release", impactSignals.productionRelease],
+      ["impact:admin-permissions", impactSignals.adminPermissions],
+      ["impact:personal-data", taskTypeSignals.dashboard && impactSignals.personalData]
+    ];
+    for (const [signal, active] of highDrivers) {
+      if (active) {
+        riskDrivers.push(signal);
+      }
+    }
+    if (riskDrivers.length > 0) {
+      riskLevel = "high";
+    } else if (mutationIntent === "readonly") {
+      riskLevel = "low";
+      riskDrivers.push("intent:readonly");
+    } else if (taskTypeSignals.docsCopy && scopeSignals.localized) {
+      riskLevel = "low";
+      riskDrivers.push("task:docs-copy");
+    } else if (taskTypeSignals.refactor || taskTypeSignals.bugfix || taskTypeSignals.landingPage || taskTypeSignals.dashboard) {
+      riskLevel = "medium";
+      if (taskTypeSignals.refactor) riskDrivers.push("task:refactor");
+      if (taskTypeSignals.bugfix) riskDrivers.push("task:bugfix");
+      if (taskTypeSignals.landingPage) riskDrivers.push("task:landing-page");
+      if (taskTypeSignals.dashboard) riskDrivers.push("task:dashboard");
+    }
+    const specPolicy = riskLevel === "high" || scopeSignals.explicitRequiredSpec || taskTypeSignals.landingPage && scopeSignals.broad ? "required" : "none";
+    return {
+      riskLevel,
+      specPolicy,
+      matchedSignals: [...new Set(matchedSignals)],
+      riskDrivers: [...new Set(riskDrivers)]
+    };
+  }
+  determineSafetyAndEvidence(text, mutationIntent) {
+    const safetyConstraints = [];
+    const requiredEvidence = [];
+    if (mutationIntent === "publish") {
+      safetyConstraints.push("Require release gate", "Awaiting user authorization");
+      requiredEvidence.push("release-decision", "tarball-hash");
+    } else if (mutationIntent === "write") {
+      safetyConstraints.push("Require branch gate", "No direct commits to main");
+      requiredEvidence.push("tests", "commit-hash");
+    } else {
+      safetyConstraints.push("No workspace mutations allowed");
+    }
+    if (/\b(bypass|force|direct)\b/i.test(text)) {
+      safetyConstraints.push("Block bypass attempts");
+    }
+    if (/\b(required evidence|evidence required)\b/i.test(text)) {
+      requiredEvidence.push("user-required-evidence");
+    }
+    if (/\b(formal spec|required spec)\b/i.test(text)) {
+      safetyConstraints.push("Require formal specification");
+    }
+    return { safetyConstraints, requiredEvidence };
+  }
+  /**
+   * Decides the routing decision.
+   */
+  route(understanding) {
+    const { operationType, mutationIntent, rawRequest } = understanding;
+    const requestedActor = void 0;
+    if (/\b(bypass safety|bypass validation|force push|directly to main|push to remote without gate)\b/i.test(rawRequest)) {
+      return {
+        requestedActor,
+        selectedActor: "Atlas",
+        operationType,
+        mutationIntent,
+        permissionDecision: "blocked",
+        reason: "Security block: Attempt to bypass safety or push directly is forbidden.",
+        workflowPath: ["Atlas"]
+      };
+    }
+    let { selectedActor, permissionDecision, reason } = this.evaluateActorPermission(operationType, mutationIntent);
+    let workflowPath = ["Atlas"];
+    if (selectedActor === "Phoenix") {
+      const requestPath = path4.join(this.cwd, ".ai-workflow/remediation-request.json");
+      let hasFindings = false;
+      if (fs5.existsSync(requestPath)) {
+        try {
+          const reqData = JSON.parse(fs5.readFileSync(requestPath, "utf8"));
+          if (reqData.affectedChecks && reqData.affectedChecks.length > 0) {
+            hasFindings = true;
+          }
+        } catch {
+        }
+      }
+      if (!hasFindings) {
+        permissionDecision = "blocked";
+        reason = "Blocked: Phoenix acts only with concrete findings and bounded remediation.";
+      }
+    }
+    if (understanding.specPolicy === "required") {
+      workflowPath.push("Nexus", "Orion");
+    }
+    if (selectedActor && !workflowPath.includes(selectedActor)) {
+      workflowPath.push(selectedActor);
+    }
+    if (selectedActor === "Atlas" && ["discover", "validate", "fix", "release", "deploy"].includes(operationType)) {
+      permissionDecision = "blocked";
+      reason = "Atlas self-execution guard: Atlas cannot silently execute specialized actor or capability requests.";
+    }
+    if (selectedActor === "Astra" && understanding.riskLevel === "high") {
+      workflowPath.push("Sage", "Phoenix", "Sage");
+    }
+    if (understanding.specPolicy === "none") {
+      workflowPath = workflowPath.filter((actor) => {
+        if (actor === "Nexus" && selectedActor !== "Nexus") return false;
+        if (actor === "Orion" && selectedActor !== "Orion") return false;
+        return true;
+      });
+    }
+    return {
+      requestedActor,
+      selectedActor,
+      operationType,
+      mutationIntent,
+      permissionDecision,
+      reason,
+      workflowPath
+    };
+  }
+  evaluateActorPermission(operationType, mutationIntent) {
+    let selectedActor;
+    let permissionDecision = "allowed";
+    let reason = "Routed successfully.";
+    if (operationType === "discover") {
+      selectedActor = "Nexus";
+    } else if (operationType === "validate") {
+      selectedActor = "Sage";
+    } else if (operationType === "fix") {
+      selectedActor = "Phoenix";
+    } else if (operationType === "implement") {
+      selectedActor = "Astra";
+    } else if (operationType === "release" || operationType === "deploy") {
+      selectedActor = "Orion";
+    } else {
+      selectedActor = mutationIntent === "write" ? "Astra" : "Atlas";
+    }
+    return { selectedActor, permissionDecision, reason };
+  }
+};
+
+// src/core/request-classifier.ts
+var RequestClassifier = class {
+  /**
+   * Classifies a natural request.
+   */
+  classify(request = "", options = {}) {
+    const text = String(request).trim();
+    if (!text) {
+      throw new Error("Cannot classify an empty request.");
+    }
+    const cwd = options.cwd || process.cwd();
+    const profile = resolveWorkflowProfile({ request: text });
+    const profileDef = getWorkflowProfile(profile);
+    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify)\b/i;
+    const isReadOnly = readOnlyPatterns.test(text);
+    const intent = isReadOnly ? "read-only" : "write";
+    const router = new RequestRouter({ cwd });
+    const requestUnderstanding = router.understand(text);
+    const routingDecision = router.route(requestUnderstanding);
+    const risk = requestUnderstanding.riskLevel;
+    const explicitRequiredEvidence = /\b(required evidence|evidence required)\b/i.test(text);
+    const explicitRequiredSpec = /\b(formal spec|required spec)\b/i.test(text);
+    const specPolicy = requestUnderstanding.specPolicy === "required" || explicitRequiredSpec ? "required" : "none";
+    const evidencePolicy = risk === "high" || requestUnderstanding.mutationIntent === "publish" || explicitRequiredEvidence ? "required" : "optional";
+    const remediationLimit = risk === "high" ? 3 : risk === "low" ? 1 : 2;
+    const specNeeded = specPolicy === "required";
+    const validationNeeded = intent === "write";
+    let legacyMode = "standard";
+    if (/\b(deep|architectural|migration|major|full|\[deep\])\b/i.test(text)) {
+      legacyMode = "full";
+    } else if (/\b(tiny|small|quick|simple|only\s+update|typo|comment|\[tiny\])\b/i.test(text)) {
+      const isPureDocsOrTypo = profile === "documentation" || /\b(typo|comment|readme|docs|documentation)\b/i.test(text);
+      if (intent === "write" && !isPureDocsOrTypo) {
+        legacyMode = "standard";
+      } else {
+        legacyMode = "quick";
+      }
+    }
+    return {
+      request: text,
+      profile,
+      owner: routingDecision.selectedActor || profileDef.owner,
+      intent: requestUnderstanding.mutationIntent === "readonly" ? "read-only" : "write",
+      mode: legacyMode,
+      risk,
+      specPolicy,
+      evidencePolicy,
+      remediationLimit,
+      riskDrivers: requestUnderstanding.riskDrivers || [],
+      matchedSignals: requestUnderstanding.matchedSignals || [],
+      specNeeded,
+      validationNeeded,
+      skills: [...profileDef.skills],
+      requestUnderstanding,
+      routingDecision
+    };
+  }
+};
+
+// src/core/execution-planner.ts
+import path5 from "path";
+var ExecutionPlanner = class {
+  cwd;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+  /**
+   * Generates an execution plan.
+   */
+  plan(classification, taskSlug = "task") {
+    const remediationLimit = classification.remediationLimit;
+    const branchNeeded = classification.intent === "write";
+    const specPath = classification.specNeeded ? path5.join("docs/workflows", taskSlug, "spec.md") : null;
+    const owner = classification.routingDecision?.selectedActor || (classification.intent === "write" ? "Astra" : classification.owner);
+    const validationsExpected = [];
+    if (classification.validationNeeded) {
+      validationsExpected.push("test");
+      if (classification.profile.startsWith("frontend")) {
+        validationsExpected.push("lint", "build");
+      } else if (classification.profile === "backend-api") {
+        validationsExpected.push("lint");
+      }
+    }
+    const restrictions = [
+      "Never commit or push directly to main/master.",
+      "Always execute behavior tests for new or modified behavior."
+    ];
+    if (classification.risk === "high") {
+      restrictions.push("Require independent validation review.");
+    }
+    return {
+      objective: classification.request,
+      scope: classification.intent === "read-only" ? "Analysis and verification" : "Implementation of requested behavior",
+      restrictions,
+      owner,
+      skills: [...classification.skills],
+      branchNeeded,
+      branchName: branchNeeded ? `feat/${taskSlug}` : null,
+      validationsExpected,
+      remediationLimit,
+      specPath,
+      specPolicy: classification.specPolicy,
+      evidencePolicy: classification.evidencePolicy,
+      riskLevel: classification.risk,
+      mode: classification.mode,
+      profile: classification.profile
+    };
+  }
+};
+
+// src/core/workflow-state-machine.ts
+var WorkflowStateMachine = class {
+  state;
+  history;
+  validTransitions;
+  constructor() {
+    this.state = "RECEIVED";
+    this.history = [{ state: this.state, timestamp: (/* @__PURE__ */ new Date()).toISOString() }];
+    this.validTransitions = {
+      RECEIVED: ["CLASSIFIED", "BLOCKED"],
+      CLASSIFIED: ["PLANNED", "BLOCKED"],
+      PLANNED: ["BRANCH_READY", "BLOCKED"],
+      BRANCH_READY: ["DELEGATED", "BLOCKED"],
+      DELEGATED: ["IMPLEMENTING", "BLOCKED"],
+      IMPLEMENTING: ["IMPLEMENTED", "BLOCKED"],
+      IMPLEMENTED: ["VALIDATING", "BLOCKED"],
+      VALIDATING: ["COMPLETED", "COMPLETED_WITH_NOTES", "REMEDIATING", "BLOCKED"],
+      REMEDIATING: ["REVALIDATING", "BLOCKED"],
+      REVALIDATING: ["COMPLETED", "COMPLETED_WITH_NOTES", "REMEDIATING", "BLOCKED"],
+      COMPLETED: [],
+      COMPLETED_WITH_NOTES: [],
+      BLOCKED: []
+    };
+  }
+  /**
+   * Transitions the machine to a new state.
+   * @param newState - The state to transition to.
+   */
+  transitionTo(newState) {
+    const allowed = this.validTransitions[this.state];
+    if (!allowed || !allowed.includes(newState)) {
+      throw new Error(`Invalid state transition: ${this.state} -> ${newState}`);
+    }
+    this.state = newState;
+    this.history.push({ state: this.state, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  getCurrentState() {
+    return this.state;
+  }
+  getHistory() {
+    return [...this.history];
+  }
+};
+
+// src/core/evidence/evidence-ledger.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+var EvidenceLedger = class {
+  cwd;
+  workflowId;
+  events;
+  constructor({ cwd = process.cwd(), workflowId = "unknown" } = {}) {
+    this.cwd = cwd;
+    this.workflowId = workflowId;
+    this.events = [];
+  }
+  /**
+   * Logs a workflow event to the ledger.
+   */
+  logEvent({
+    actor,
+    eventType,
+    provenance,
+    data = {},
+    actorType,
+    observed,
+    runtime
+  }) {
+    const event = {
+      workflowId: this.workflowId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actor,
+      actorType: actorType !== void 0 ? actorType : void 0,
+      observed: observed !== void 0 ? observed : void 0,
+      runtime: runtime !== void 0 ? runtime : void 0,
+      eventType,
+      provenance,
+      data
+    };
+    this.events.push(event);
+    console.log(`[LEDGER] [${actor}] ${eventType}: ${JSON.stringify(data)}`);
+    return event;
+  }
+  getEvents() {
+    return this.events;
+  }
+  /**
+   * Saves the ledger events to a JSON file.
+   */
+  async save(filePath) {
+    const targetPath = path6.isAbsolute(filePath) ? filePath : path6.join(this.cwd, filePath);
+    await fs6.mkdir(path6.dirname(targetPath), { recursive: true });
+    await fs6.writeFile(targetPath, JSON.stringify(this.events, null, 2), "utf8");
+  }
+  async verifyRoleConfinement() {
+    const violations = [];
+    const events = this.events;
+    const atlasImplements = events.some((e) => e.actor === "Atlas" && (e.eventType === "implementation_start" || e.eventType === "implementation_complete"));
+    if (atlasImplements) {
+      violations.push("Atlas cannot implement directly");
+    }
+    const nexusMutates = events.some((e) => e.actor === "Nexus" && e.eventType === "file_mutate");
+    if (nexusMutates) {
+      violations.push("Nexus cannot mutate files during discovery");
+    }
+    const sageValidates = events.some((e) => e.actor === "Sage" && (e.eventType === "validation_start" || e.eventType === "validation_complete"));
+    const hasFidelity = events.some((e) => e.eventType === "fidelity_check" || e.eventType === "fidelity_verification");
+    if (sageValidates && !hasFidelity) {
+      violations.push("Sage cannot validate without fidelity evidence");
+    }
+    const phoenixRemediates = events.find((e) => e.actor === "Phoenix" && e.eventType === "remediation_start");
+    if (phoenixRemediates) {
+      const findings = phoenixRemediates.data?.findings;
+      if (!findings || findings.length === 0) {
+        violations.push("Phoenix cannot perform remediation without findings");
+      }
+    }
+    const orionReleases = events.find((e) => e.actor === "Orion" && e.eventType === "release_start");
+    if (orionReleases) {
+      const approvals = orionReleases.data?.approvals;
+      if (!approvals || approvals.length === 0) {
+        violations.push("Orion cannot release without explicit approval");
+      }
+    }
+    const passed = violations.length === 0;
+    return {
+      passed,
+      status: passed ? "PASS" : "BLOCKED",
+      reason: violations.length > 0 ? `Role violations: ${violations.join("; ")}` : "Verification passed",
+      violations
+    };
+  }
+};
+
+// src/core/delegation-controller.ts
+var DelegationController = class {
+  cwd;
+  ledger;
+  adapter;
+  lastRoutingDecision;
+  constructor({ cwd = process.cwd(), ledger, adapter } = {}) {
+    this.cwd = cwd;
+    this.ledger = ledger;
+    this.adapter = adapter || new OpenCodeAdapter({ cwd });
+    this.lastRoutingDecision = null;
+  }
+  /**
+   * Logs routing decision by Atlas.
+   */
+  async route(naturalRequest, classification) {
+    const decision = classification.routingDecision ?? {
+      operationType: "explain",
+      mutationIntent: "readonly",
+      permissionDecision: "allowed",
+      reason: "no routing decision",
+      workflowPath: []
+    };
+    this.lastRoutingDecision = decision;
+    if (this.ledger) {
+      this.ledger.logEvent({
+        actor: "Atlas",
+        actorType: "control-plane",
+        observed: true,
+        eventType: "routing",
+        provenance: "request-classifier",
+        data: {
+          request: naturalRequest,
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          operationType: decision.operationType || null,
+          mutationIntent: decision.mutationIntent || null,
+          permissionDecision: decision.permissionDecision || null,
+          reason: decision.reason || null,
+          workflowPath: decision.workflowPath || [],
+          classification,
+          event: "routing.completed",
+          runtimeAgentRequested: null,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: false,
+          status: decision.permissionDecision === "blocked" ? "BLOCKED" : "COMPLETED"
+        }
+      });
+    }
+  }
+  /**
+   * Logs and executes the implementation process by Astra.
+   */
+  async implement(promptMsg, owner, options = {}) {
+    const decision = this.lastRoutingDecision ?? {
+      operationType: "explain",
+      mutationIntent: "readonly",
+      permissionDecision: "allowed",
+      reason: "no routing decision",
+      workflowPath: []
+    };
+    const inspection = await this.adapter.inspect();
+    const isSpecialized = ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(owner);
+    const supportsAgent = inspection.supports?.agent;
+    const canApply = !isSpecialized || supportsAgent;
+    const runtimeAgentSelectionMode = isSpecialized ? supportsAgent ? "explicit" : "prompt-fallback" : "default";
+    if (this.ledger) {
+      this.ledger.logEvent({
+        actor: canApply ? owner : "Atlas",
+        actorType: canApply ? "runtime-agent" : "control-plane",
+        observed: true,
+        runtime: "opencode",
+        eventType: "implementation_start",
+        provenance: "opencode-adapter",
+        data: {
+          agent: owner,
+          prompt: promptMsg,
+          event: "implementation.started",
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          runtimeAgentRequested: owner,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: supportsAgent || false,
+          runtimeAgentSelectionMode,
+          permissionDecision: decision.permissionDecision || null,
+          reason: decision.reason || null,
+          status: "started"
+        }
+      });
+    }
+    const runResult = await this.adapter.execute(promptMsg, { agent: owner, ...options });
+    if (this.ledger) {
+      const isApplied = runResult.runtimeAgentApplied === owner;
+      this.ledger.logEvent({
+        actor: isApplied ? owner : "Atlas",
+        actorType: isApplied ? "runtime-agent" : "control-plane",
+        observed: true,
+        runtime: "opencode",
+        eventType: "implementation_complete",
+        provenance: "opencode-adapter",
+        data: {
+          success: runResult.success,
+          commandsRun: runResult.commandsRun || [],
+          eventCount: runResult.eventCount || 0,
+          error: runResult.error,
+          event: "implementation.completed",
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          runtimeAgentRequested: runResult.runtimeAgentRequested || owner || null,
+          runtimeAgentApplied: runResult.runtimeAgentApplied || null,
+          runtimeAgentSupported: runResult.runtimeAgentSupported !== void 0 ? runResult.runtimeAgentSupported : supportsAgent || false,
+          runtimeAgentSelectionMode: runResult.runtimeAgentSelectionMode || runtimeAgentSelectionMode,
+          permissionDecision: decision.permissionDecision || null,
+          reason: runResult.error || decision.reason || null,
+          status: runResult.status || (runResult.success ? "COMPLETED" : "FAILED")
+        }
+      });
+    }
+    return runResult;
+  }
+  /**
+   * Runs validation locally without logging Sage since no validation agent runtime was executed.
+   */
+  async validate(taskSlug, profile, verifyFn, evidencePolicy) {
+    const result = await verifyFn();
+    const isRequired = evidencePolicy === "required";
+    if (isRequired) {
+      const decision = this.lastRoutingDecision ?? {
+        operationType: "explain",
+        mutationIntent: "readonly",
+        permissionDecision: "allowed",
+        reason: "no routing decision",
+        workflowPath: []
+      };
+      const inspection = await this.adapter.inspect();
+      const supportsAgent = inspection.supports?.agent;
+      const canApply = supportsAgent;
+      const runtimeAgentSelectionMode = supportsAgent ? "explicit" : "prompt-fallback";
+      if (this.ledger) {
+        this.ledger.logEvent({
+          actor: canApply ? "Sage" : "Atlas",
+          actorType: canApply ? "auditor" : "control-plane",
+          observed: true,
+          runtime: "opencode",
+          eventType: "validation_start",
+          provenance: "opencode-adapter",
+          data: {
+            agent: "Sage",
+            event: "validation.started",
+            requestedActor: decision.requestedActor || null,
+            selectedActor: decision.selectedActor || null,
+            runtimeAgentRequested: "Sage",
+            runtimeAgentApplied: null,
+            runtimeAgentSupported: supportsAgent || false,
+            runtimeAgentSelectionMode,
+            permissionDecision: decision.permissionDecision || null,
+            reason: decision.reason || null,
+            status: "started"
+          }
+        });
+      }
+      let gitDiff = "";
+      try {
+        const { execSync: execSync6 } = await import("child_process");
+        gitDiff = execSync6("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      } catch {
+      }
+      const prompt = `Please validate the implementation. Diff:
+${gitDiff}
+Local Evidence:
+${JSON.stringify(result, null, 2)}`;
+      const runResult = await this.adapter.execute(prompt, { agent: "Sage" });
+      if (this.ledger) {
+        const isApplied = runResult.runtimeAgentApplied === "Sage";
+        this.ledger.logEvent({
+          actor: isApplied ? "Sage" : "Atlas",
+          actorType: isApplied ? "auditor" : "control-plane",
+          observed: true,
+          runtime: "opencode",
+          eventType: "validation_complete",
+          provenance: "opencode-adapter",
+          data: {
+            success: runResult.success,
+            commandsRun: runResult.commandsRun || [],
+            eventCount: runResult.eventCount || 0,
+            error: runResult.error,
+            event: "validation.completed",
+            requestedActor: decision.requestedActor || null,
+            selectedActor: decision.selectedActor || null,
+            runtimeAgentRequested: runResult.runtimeAgentRequested || "Sage",
+            runtimeAgentApplied: runResult.runtimeAgentApplied || null,
+            runtimeAgentSupported: runResult.runtimeAgentSupported !== void 0 ? runResult.runtimeAgentSupported : supportsAgent || false,
+            runtimeAgentSelectionMode: runResult.runtimeAgentSelectionMode || runtimeAgentSelectionMode,
+            permissionDecision: decision.permissionDecision || null,
+            reason: runResult.error || decision.reason || null,
+            status: runResult.status || (runResult.success ? "COMPLETED" : "FAILED")
+          }
+        });
+      }
+      if (!runResult.success) {
+        result.overallStatus = "FAIL_QUALITY_GATE";
+      }
+    }
+    return result;
+  }
+};
+
+// src/core/finalization/workspace-snapshot.ts
+import fs7 from "fs/promises";
+import path7 from "path";
+import crypto2 from "crypto";
+import { execSync as execSync4 } from "child_process";
+var WorkspaceSnapshot = class {
+  cwd;
+  fastTrack;
+  constructor({ cwd = process.cwd(), fastTrack = false } = {}) {
+    this.cwd = cwd;
+    this.fastTrack = fastTrack;
+  }
+  isIgnored(relativePath) {
+    const norm = relativePath.replaceAll("\\", "/");
+    if (norm === "node_modules" || norm.startsWith("node_modules/")) return true;
+    if (norm === "vendor" || norm.startsWith("vendor/")) return true;
+    if (norm === ".git" || norm.startsWith(".git/")) return true;
+    if (norm === "EVIDENCE.json") return true;
+    if (norm === ".ai-workflow/EVIDENCE.json") return true;
+    if (norm.startsWith(".ai-workflow/history/")) return true;
+    if (norm.startsWith(".ai-workflow/handoffs/")) return true;
+    return false;
+  }
+  async capture() {
+    const files = {};
+    const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+    if (!this.fastTrack || isTest) {
+      await this.scanDir(this.cwd, files);
+    }
+    const execGit = (args) => {
+      try {
+        return execSync4(`git ${args}`, { cwd: this.cwd, encoding: "utf8", stdio: "pipe" }).trim();
+      } catch {
+        return "";
+      }
+    };
+    const branch = execGit("rev-parse --abbrev-ref HEAD");
+    const head = execGit("rev-parse HEAD");
+    const indexTree = execGit("write-tree");
+    const stagedDiff = execGit("diff --cached");
+    const unstagedDiff = execGit("diff");
+    const untrackedFiles = execGit("status --porcelain");
+    const hashString = (str) => {
+      return crypto2.createHash("sha256").update(str).digest("hex");
+    };
+    return {
+      branch,
+      head,
+      indexTree,
+      files,
+      stagedDiffHash: hashString(stagedDiff),
+      unstagedDiffHash: hashString(unstagedDiff),
+      untrackedFilesHash: hashString(untrackedFiles)
+    };
+  }
+  async scanDir(dir, filesMap) {
+    try {
+      const entries = await fs7.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path7.join(dir, entry.name);
+        const relativePath = path7.relative(this.cwd, fullPath);
+        if (this.isIgnored(relativePath)) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          await this.scanDir(fullPath, filesMap);
+        } else if (entry.isFile()) {
+          try {
+            const stat = await fs7.stat(fullPath);
+            const content = await fs7.readFile(fullPath);
+            const sha256 = crypto2.createHash("sha256").update(content).digest("hex");
+            const isExecutable = (stat.mode & 73) !== 0;
+            const mode = isExecutable ? "100755" : "100644";
+            filesMap[relativePath] = {
+              sha256,
+              mode
+            };
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  calculateHash(snapshot) {
+    const hash = crypto2.createHash("sha256");
+    hash.update(snapshot.branch || "");
+    hash.update(snapshot.head || "");
+    hash.update(snapshot.indexTree || "");
+    hash.update(snapshot.stagedDiffHash || "");
+    hash.update(snapshot.unstagedDiffHash || "");
+    hash.update(snapshot.untrackedFilesHash || "");
+    const sortedFiles = Object.keys(snapshot.files || {}).sort();
+    for (const file of sortedFiles) {
+      hash.update(file);
+      hash.update(snapshot.files[file].sha256);
+      hash.update(snapshot.files[file].mode);
+    }
+    return hash.digest("hex");
+  }
+};
+
+// src/core/finalization/finalizer.ts
+import { execSync as execSync5 } from "child_process";
+import path8 from "path";
+import fs8 from "fs/promises";
+var Finalizer = class {
+  cwd;
+  snapshotManager;
+  fastTrack;
+  constructor({ cwd = process.cwd(), fastTrack = false } = {}) {
+    this.cwd = cwd;
+    this.snapshotManager = new WorkspaceSnapshot({ cwd, fastTrack });
+    this.fastTrack = fastTrack;
+  }
+  getChangedFilesFromGit() {
+    try {
+      const files = /* @__PURE__ */ new Set();
+      const diff = execSync5("git diff --name-only HEAD", { cwd: this.cwd, encoding: "utf8" });
+      diff.split("\n").map((f) => f.trim()).filter(Boolean).forEach((f) => files.add(f));
+      const status = execSync5("git status --short --untracked-files=all", { cwd: this.cwd, encoding: "utf8" });
+      status.split("\n").forEach((line) => {
+        const match = line.match(/^(?:[ MADRCU?!]{2}\s+|[MADRCU?!]\s+)(.+)$/);
+        if (match) {
+          const candidate = match[1].trim();
+          const renamed = candidate.includes(" -> ") ? candidate.split(" -> ").at(-1) : candidate;
+          if (renamed) files.add(renamed);
+        }
+      });
+      return [...files].sort();
+    } catch {
+      return [];
+    }
+  }
+  async verifyFidelity(arg) {
+    let userRequest = null;
+    let projectContext = null;
+    let deliveryDecision = null;
+    let changedFiles = null;
+    let evidence = null;
+    let explicitApprovals = [];
+    if (Array.isArray(arg)) {
+      changedFiles = arg;
+    } else if (arg && typeof arg === "object") {
+      userRequest = arg.userRequest;
+      projectContext = arg.projectContext;
+      deliveryDecision = arg.deliveryDecision;
+      changedFiles = arg.changedFiles;
+      evidence = arg.evidence;
+      explicitApprovals = arg.explicitApprovals || [];
+    }
+    const filesToCheck = changedFiles || this.getChangedFilesFromGit();
+    const decisionEngine = new DeliveryDecisionEngine({ cwd: this.cwd });
+    const actualProjectContext = projectContext || await decisionEngine.detectContext();
+    const actualUserRequest = userRequest || "";
+    const actualDeliveryDecision = deliveryDecision || await decisionEngine.determineDecision({
+      userRequest: actualUserRequest,
+      projectContext: actualProjectContext,
+      explicitApprovals
+    });
+    const actualDeliveryClass = await decisionEngine.determineClass(filesToCheck);
+    const fidelityGate = new ArtifactFidelityGate({
+      cwd: this.cwd,
+      deliveryClass: actualDeliveryClass,
+      userRequest: actualUserRequest,
+      explicitApprovals
+    });
+    const requestFidelity = await fidelityGate.verifyRequestFidelity({
+      userRequest: actualUserRequest,
+      deliveryDecision: actualDeliveryDecision,
+      projectContext: actualProjectContext,
+      changedFiles: filesToCheck,
+      evidence,
+      explicitApprovals
+    });
+    const verifyResult = await fidelityGate.verify(filesToCheck);
+    let passed = requestFidelity.passed && verifyResult.passed;
+    let reason = !requestFidelity.passed ? requestFidelity.reason : verifyResult.reason;
+    const evidencePath = path8.join(this.cwd, "EVIDENCE.json");
+    const hasEvidence = await fs8.access(evidencePath).then(() => true).catch(() => false);
+    if (hasEvidence) {
+      const { EvidenceValidator } = await import("./evidence-validator-76ZQQYDU.js");
+      const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+      const evidenceValidator = new EvidenceValidator({ cwd: this.cwd, skipFileCheck: isTest, skipGitCheck: isTest });
+      const valResult = await evidenceValidator.validate();
+      if (!valResult.valid) {
+        console.error("EVIDENCE VALIDATOR FAILED REASON:", valResult.reason);
+        passed = false;
+        reason = valResult.reason;
+      }
+    }
+    return {
+      passed,
+      status: requestFidelity.status || (passed ? "PASS" : "BLOCKED"),
+      reason,
+      deliveryClass: actualDeliveryClass,
+      requestFidelity
+    };
+  }
+  /**
+   * Compares the current workspace state with a previously captured snapshot.
+   */
+  async verifyIntegrity(previousSnapshot) {
+    const currentSnapshot = await this.snapshotManager.capture();
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    let valid = true;
+    if (previousSnapshot.branch !== currentSnapshot.branch) {
+      modified.push(`branch:${previousSnapshot.branch}->${currentSnapshot.branch}`);
+      valid = false;
+    }
+    if (previousSnapshot.head !== currentSnapshot.head) {
+      modified.push(`head:${previousSnapshot.head}->${currentSnapshot.head}`);
+      valid = false;
+    }
+    if (previousSnapshot.indexTree !== currentSnapshot.indexTree) {
+      modified.push(`indexTree:${previousSnapshot.indexTree}->${currentSnapshot.indexTree}`);
+      valid = false;
+    }
+    if (previousSnapshot.stagedDiffHash !== currentSnapshot.stagedDiffHash) {
+      modified.push("stagedDiff");
+      valid = false;
+    }
+    if (previousSnapshot.unstagedDiffHash !== currentSnapshot.unstagedDiffHash) {
+      modified.push("unstagedDiff");
+      valid = false;
+    }
+    if (previousSnapshot.untrackedFilesHash !== currentSnapshot.untrackedFilesHash) {
+      modified.push("untrackedFiles");
+      valid = false;
+    }
+    const prevFiles = previousSnapshot.files || {};
+    const currFiles = currentSnapshot.files || {};
+    for (const [file, info] of Object.entries(currFiles)) {
+      const prevInfo = prevFiles[file];
+      if (!prevInfo) {
+        added.push(file);
+      } else if (prevInfo.sha256 !== info.sha256 || prevInfo.mode !== info.mode) {
+        modified.push(file);
+      }
+    }
+    for (const file of Object.keys(prevFiles)) {
+      if (!currFiles[file]) {
+        deleted.push(file);
+      }
+    }
+    if (added.length > 0 || modified.length > 0 || deleted.length > 0) {
+      valid = false;
+    }
+    return {
+      valid,
+      changes: { added, modified, deleted }
+    };
+  }
+};
+
+export {
+  readPackageFile,
+  getPackageVersion,
+  discoverPackageFiles,
+  getFullSkillFiles,
+  getFullAgentContent,
+  isRecoverableGateFailure,
+  isTerminalFailure,
+  COMPLETION_STATUS_TEXT,
+  OpenCodeAdapter,
+  BranchGate,
+  SpecValidator,
+  HandoffEngine,
+  HealerEngine,
+  getWorkflowProfile,
+  resolveWorkflowProfile,
+  RequestClassifier,
+  ExecutionPlanner,
+  WorkflowStateMachine,
+  EvidenceLedger,
+  DelegationController,
+  Finalizer
+};
+//# sourceMappingURL=chunk-UHLZX2EG.js.map