@williambeto/ai-workflow 2.7.1 → 2.8.0

package/{chunk-W4RTQWVQ.js → chunk-LI76KI7C.js}

@@ -94,6 +94,21 @@ var AGENT_PROMPT_CONTRACTS = {
   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."
 };
+function extractSdkExecution(data, requestedAgent) {
+  const parts = data?.parts || [];
+  const output = parts.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  const commandsRun = parts.filter((part) => part.type === "tool").map((part) => part.state?.input?.command ?? part.state?.input?.CommandLine).filter((command) => typeof command === "string");
+  const appliedAgent = typeof data?.info?.agent === "string" ? data.info.agent : null;
+  const confirmed = appliedAgent === requestedAgent;
+  return {
+    success: !data?.info?.error && confirmed,
+    commandsRun,
+    eventCount: parts.length,
+    runtimeAgentApplied: appliedAgent,
+    runtimeActorConfirmation: confirmed ? "confirmed" : "unavailable",
+    output
+  };
+}
 var OpenCodeAdapter = class {
   cwd;
   constructor({ cwd = process.cwd() } = {}) {
@@ -110,13 +125,14 @@ var OpenCodeAdapter = class {
       if (!available) {
         return {
           available: false,
-          supports: { run: false, formatJson: false, agent: false, model: false }
+          supports: { run: false, server: false, formatJson: false, agent: false, model: false }
         };
       }
       return {
         available: true,
         supports: {
           run: /\brun\b/.test(cliHelp.stdout),
+          server: /\bserve\b/.test(cliHelp.stdout),
           formatJson: /--format/.test(runHelp.stdout),
           agent: /--agent/.test(runHelp.stdout),
           model: /--model/.test(runHelp.stdout)
@@ -125,14 +141,14 @@ var OpenCodeAdapter = class {
     } catch {
       return {
         available: false,
-        supports: { run: false, formatJson: false, agent: false, model: false }
+        supports: { run: false, server: 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 } = {}) {
+  async execute(message, { agent = null, model = null, readOnly = false, fastTrack = false, requireActorConfirmation = false } = {}) {
     const inspection = await this.inspect();
     const isSpecializedAgent = agent && ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(agent);
     if (!readOnly) {
@@ -152,6 +168,8 @@ var OpenCodeAdapter = class {
             runtimeAgentApplied: null,
             runtimeAgentSupported: false,
             runtimeAgentSelectionMode: "unsupported",
+            runtimeActorConfirmation: "unavailable",
+            output: "",
             commandsRun: [],
             eventCount: 0
           };
@@ -159,16 +177,20 @@ var OpenCodeAdapter = class {
       }
     }
     if (!inspection.available) {
+      console.warn("\\n[WARNING] OpenCode CLI is not installed or not available in the system PATH.");
+      console.warn("[WARNING] Graceful degradation active: simulating successful execution (dry-run).\\n");
       return {
-        success: false,
-        status: isSpecializedAgent ? "BLOCKED" : "FAILED",
+        success: true,
+        status: "DEGRADED",
         commandsRun: [],
         eventCount: 0,
-        error: "OpenCode CLI is not installed or not available in the system PATH.",
+        error: "OpenCode CLI missing. Simulated execution.",
         runtimeAgentRequested: agent || null,
         runtimeAgentApplied: null,
         runtimeAgentSupported: false,
-        runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
+        runtimeAgentSelectionMode: "degraded",
+        runtimeActorConfirmation: "unavailable",
+        output: ""
       };
     }
     const usePromptFallback = Boolean(isSpecializedAgent && !inspection.supports.agent && agent);
@@ -179,6 +201,73 @@ Runtime agent selection note: requested actor '${agent}' could not be applied wi
 User request:
 ${message}` : message;
     const runtimeAgentSelectionMode = isSpecializedAgent ? usePromptFallback ? "prompt-fallback" : "explicit" : "default";
+    const runWithSdk = async (targetCwd) => {
+      if (!agent) {
+        return {
+          success: false,
+          status: "BLOCKED",
+          error: "Actor confirmation requires a requested agent.",
+          commandsRun: [],
+          eventCount: 0,
+          runtimeAgentRequested: null,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: inspection.supports.agent,
+          runtimeAgentSelectionMode: "sdk-session",
+          runtimeActorConfirmation: "unavailable",
+          output: ""
+        };
+      }
+      let server;
+      try {
+        const { createOpencode } = await import("@opencode-ai/sdk/v2");
+        const runtime = await createOpencode({ port: 0, timeout: 1e4 });
+        server = runtime.server;
+        const permissions = readOnly ? [
+          { permission: "edit", pattern: "*", action: "deny" },
+          { permission: "bash", pattern: "*", action: "deny" },
+          { permission: "task", pattern: "*", action: "deny" },
+          { permission: "external_directory", pattern: "*", action: "deny" }
+        ] : void 0;
+        const session = await runtime.client.session.create({
+          directory: targetCwd,
+          title: `AI Workflow Kit: ${agent}`,
+          agent,
+          permission: permissions
+        }, { throwOnError: true });
+        const response = await runtime.client.session.prompt({
+          sessionID: session.data.id,
+          directory: targetCwd,
+          agent,
+          parts: [{ type: "text", text: message }]
+        }, { throwOnError: true });
+        const extracted = extractSdkExecution(response.data, agent);
+        if (extracted.output) process.stdout.write(extracted.output);
+        return {
+          ...extracted,
+          status: extracted.success ? "COMPLETED" : "BLOCKED",
+          error: extracted.success ? void 0 : extracted.runtimeAgentApplied ? `Runtime confirmed actor '${extracted.runtimeAgentApplied}', expected '${agent}'.` : `Runtime did not provide machine-readable confirmation for actor '${agent}'.`,
+          runtimeAgentRequested: agent,
+          runtimeAgentSupported: inspection.supports.agent,
+          runtimeAgentSelectionMode: "sdk-session"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          status: "BLOCKED",
+          error: `OpenCode SDK actor confirmation failed: ${error.message}`,
+          commandsRun: [],
+          eventCount: 0,
+          runtimeAgentRequested: agent,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: inspection.supports.agent,
+          runtimeAgentSelectionMode: "sdk-session",
+          runtimeActorConfirmation: "unavailable",
+          output: ""
+        };
+      } finally {
+        server?.close();
+      }
+    };
     const runInWorkspace = async (targetCwd) => {
       return new Promise((resolve2) => {
         const args = ["run", runtimeMessage];
@@ -203,14 +292,20 @@ ${message}` : message;
         });
         const commandsRun = [];
         let eventCount = 0;
+        let output = "";
+        let confirmedAgent = null;
         rl.on("line", (line) => {
           const trimmed = line.trim();
           if (!trimmed) return;
           try {
             const event = JSON.parse(trimmed);
             eventCount++;
+            if (event.type === "agent_identity" && event.confirmed === true && typeof event.agent === "string") {
+              confirmedAgent = event.agent;
+            }
             if (event.type === "text" && event.part?.text) {
               process.stdout.write(event.part.text);
+              output += event.part.text;
             }
             if (event.type === "step_start" && event.part?.toolCalls) {
               for (const call of event.part.toolCalls) {
@@ -240,7 +335,9 @@ ${message}` : message;
                       runtimeAgentRequested: agent || null,
                       runtimeAgentApplied: usePromptFallback ? null : null,
                       runtimeAgentSupported: inspection.supports.agent,
-                      runtimeAgentSelectionMode
+                      runtimeAgentSelectionMode,
+                      runtimeActorConfirmation: confirmedAgent ? "confirmed" : "unavailable",
+                      output
                     });
                     return;
                   }
@@ -258,9 +355,11 @@ ${message}` : message;
             commandsRun,
             eventCount,
             runtimeAgentRequested: agent || null,
-            runtimeAgentApplied: isSpecializedAgent && !usePromptFallback ? agent : null,
+            runtimeAgentApplied: isSpecializedAgent ? confirmedAgent : null,
             runtimeAgentSupported: inspection.supports.agent,
-            runtimeAgentSelectionMode
+            runtimeAgentSelectionMode,
+            runtimeActorConfirmation: confirmedAgent ? "confirmed" : "unavailable",
+            output
           });
         });
         child.on("error", (err) => {
@@ -274,171 +373,75 @@ ${message}` : message;
             runtimeAgentRequested: agent || null,
             runtimeAgentApplied: null,
             runtimeAgentSupported: inspection.supports.agent,
-            runtimeAgentSelectionMode
+            runtimeAgentSelectionMode,
+            runtimeActorConfirmation: "unavailable",
+            output
           });
         });
       });
     };
+    const runner = requireActorConfirmation && inspection.supports.server ? runWithSdk : runInWorkspace;
     if (readOnly && !fastTrack) {
       const { runInReadOnlyWorkspace } = await import("./read-only-workspace-PZBE7KAX.js");
-      return runInReadOnlyWorkspace(this.cwd, runInWorkspace);
+      return runInReadOnlyWorkspace(this.cwd, runner);
     } else {
-      return runInWorkspace(this.cwd);
+      return runner(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 };
+// src/core/sdd/validator.ts
+import fs from "fs/promises";
+var SpecValidator = class {
+  validateContent(content, requiredStatus = "APPROVED") {
+    const title = content.split(/\r?\n/, 1)[0]?.trim() || "";
+    let tier = "unknown";
+    if (/^#\s+\[DEEP\](?:\s|$)/.test(title)) tier = "deep";
+    else if (/^#\s+\[STANDARD\](?:\s|$)/.test(title)) tier = "standard";
+    else if (/^#\s+\[TINY\](?:\s|$)/.test(title)) tier = "tiny";
+    if (tier === "unknown") {
+      return { valid: false, reason: "Specification tier [DEEP|STANDARD|TINY] not identified in title." };
+    }
+    if (!/^## Metadata\s*$/m.test(content)) {
+      return { valid: false, reason: "Missing '## Metadata' section.", tier };
+    }
+    if (!/^## Acceptance Criteria\s*$/m.test(content)) {
+      return { valid: false, reason: "Missing '## Acceptance Criteria' section.", tier };
+    }
+    const statusMatch = content.match(/^\s*-?\s*(?:\*\*)?Status(?:\*\*)?\s*:\s*(.+?)\s*$/im);
+    if (!statusMatch) {
+      return { valid: false, reason: "Missing Status field in Metadata section.", tier };
+    }
+    const status = statusMatch[1].replace(/[\*_`]/g, "").trim().toUpperCase();
+    if (status.includes("|")) {
+      return { valid: false, reason: `Specification status is a template list. Must be explicitly set to '${requiredStatus}'.`, tier };
+    }
+    if (status !== requiredStatus) {
+      return { valid: false, reason: `Specification status is '${status}', but must be '${requiredStatus}' to proceed.`, tier };
+    }
+    if (requiredStatus === "DRAFT") {
+      if (tier !== "deep") {
+        return { valid: false, reason: "Executable SDD discovery requires a [DEEP] specification.", tier };
       }
-      const isProtected = this.protectedBranches.includes(currentBranch);
-      if (!isProtected) {
-        return { blocked: false, branch: currentBranch, recovered: false };
+      if (!/^\s*-\s*\[\s\]\s+\S+/m.test(content)) {
+        return { valid: false, reason: "DRAFT specification must contain at least one concrete unchecked acceptance criterion.", tier };
       }
-      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 };
+      if (/(?:\$\{[^}]+\}|<[^>\n]+>|\b(?:TODO|TBD|PLACEHOLDER)\b)/i.test(content)) {
+        return { valid: false, reason: "DRAFT specification contains unresolved template placeholders.", tier };
       }
-      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 };
     }
+    return { valid: true, tier };
+  }
+  validateDraftContent(content) {
+    return this.validateContent(content, "DRAFT");
   }
-};
-
-// 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 };
+      const content = await fs.readFile(filePath, "utf8");
+      return this.validateContent(content, "APPROVED");
     } catch (error) {
       if (error.code === "ENOENT") {
         return { valid: false, reason: `Specification file not found: ${filePath}` };
@@ -449,9 +452,9 @@ var SpecValidator = class {
 };
 
 // src/core/handoff/handoff-engine.ts
-import { execSync as execSync3 } from "child_process";
-import fs3 from "fs/promises";
-import path2 from "path";
+import { execSync as execSync2 } from "child_process";
+import fs2 from "fs/promises";
+import path from "path";
 var HandoffEngine = class {
   cwd;
   constructor({ cwd }) {
@@ -464,9 +467,9 @@ var HandoffEngine = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     let specsContent = "";
     for (const specPath of specPaths) {
-      const absolutePath = path2.isAbsolute(specPath) ? specPath : path2.join(this.cwd, specPath);
+      const absolutePath = path.isAbsolute(specPath) ? specPath : path.join(this.cwd, specPath);
       try {
-        const content = await fs3.readFile(absolutePath, "utf8");
+        const content = await fs2.readFile(absolutePath, "utf8");
         specsContent += `### File: ${specPath}
 
 ${content}
@@ -482,7 +485,7 @@ ${content}
     }
     let gitDiff = "No changes detected.";
     try {
-      gitDiff = execSync3("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "No changes detected.";
+      gitDiff = execSync2("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "No changes detected.";
     } catch (err) {
       gitDiff = `[Error capturing diff: ${err.message}]`;
     }
@@ -493,9 +496,9 @@ ${content}
       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");
+      const evidencePath = path.join(this.cwd, "EVIDENCE.json");
       try {
-        const content = await fs3.readFile(evidencePath, "utf8");
+        const content = await fs2.readFile(evidencePath, "utf8");
         const data = JSON.parse(content);
         evidenceJson = JSON.stringify(data, null, 2);
         evidenceSummary = `Status: ${data.status}, Commands: ${data.commands?.length || 0}`;
@@ -503,16 +506,16 @@ ${content}
       }
     }
     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")
+      path.join(this.cwd, ".ai-workflow/templates/HANDOFF.template.md"),
+      path.join(this.cwd, ".ai-workflow/harness/handoffs/HANDOFF.template.md"),
+      path.join(getPackageRoot(), "dist-assets/templates/HANDOFF.template.md"),
+      path.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");
+        template = await fs2.readFile(tPath, "utf8");
         break;
       } catch (err) {
         lastError = err;
@@ -524,18 +527,18 @@ ${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 handoffDir = path.join(this.cwd, ".ai-workflow/handoffs");
+    await fs2.mkdir(handoffDir, { recursive: true });
     const packetName = `HANDOFF-${taskId || "TMP"}-${Date.now()}.md`;
-    const packetPath = path2.join(handoffDir, packetName);
-    await fs3.writeFile(packetPath, packet);
+    const packetPath = path.join(handoffDir, packetName);
+    await fs2.writeFile(packetPath, packet);
     return packetPath;
   }
 };
 
 // src/core/healing/healer-engine.ts
-import fs4 from "fs/promises";
-import path3 from "path";
+import fs3 from "fs/promises";
+import path2 from "path";
 import crypto from "crypto";
 
 // src/core/statuses.ts
@@ -608,7 +611,7 @@ var HealerEngine = class {
     this.ledger = ledger;
   }
   get statePath() {
-    return path3.join(this.cwd, ".ai-workflow", `healing-state-${this.taskSlug}.json`);
+    return path2.join(this.cwd, ".ai-workflow", `healing-state-${this.taskSlug}.json`);
   }
   fingerprint(result) {
     return crypto.createHash("sha256").update(stableJson(collectBlockingFindings(result))).digest("hex");
@@ -628,18 +631,18 @@ var HealerEngine = class {
     return false;
   }
   async writeState(state) {
-    await fs4.mkdir(path3.dirname(this.statePath), { recursive: true });
-    await fs4.writeFile(this.statePath, JSON.stringify(state, null, 2));
+    await fs3.mkdir(path2.dirname(this.statePath), { recursive: true });
+    await fs3.writeFile(this.statePath, JSON.stringify(state, null, 2));
   }
   async resetState() {
     try {
-      await fs4.unlink(this.statePath);
+      await fs3.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 requestPath = path2.join(this.cwd, ".ai-workflow", "remediation-request.json");
+    await fs3.mkdir(path2.dirname(requestPath), { recursive: true });
     const request = {
       taskSlug: this.taskSlug,
       executionMode: this.mode,
@@ -650,7 +653,7 @@ var HealerEngine = class {
       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));
+    await fs3.writeFile(requestPath, JSON.stringify(request, null, 2));
     return requestPath;
   }
   async run({
@@ -756,601 +759,166 @@ var HealerEngine = class {
   }
 };
 
-// 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 {
+// src/core/evidence/evidence-ledger.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+import { createHash } from "crypto";
+var EvidenceLedger = class {
   cwd;
-  constructor({ cwd = process.cwd() } = {}) {
+  workflowId;
+  events;
+  loadedPath;
+  loadedContentHash;
+  constructor({ cwd = process.cwd(), workflowId = "unknown" } = {}) {
     this.cwd = cwd;
+    this.workflowId = workflowId;
+    this.events = [];
+    this.loadedPath = null;
+    this.loadedContentHash = null;
   }
   /**
-   * Understands and classifies a natural language request.
+   * Logs a workflow event to the ledger.
    */
-  understand(request) {
-    const text = String(request).trim();
-    if (!text) {
-      throw new Error("Cannot classify an empty request.");
+  logEvent({
+    actor,
+    eventType,
+    provenance,
+    data = {},
+    actorType,
+    observed,
+    runtime
+  }) {
+    const uniqueTerminalEvents = /* @__PURE__ */ new Set(["specification_complete", "planning_complete", "implementation_complete"]);
+    if (uniqueTerminalEvents.has(eventType) && this.events.some((event2) => event2.eventType === eventType)) {
+      throw new Error(`Conflicting ledger record: terminal event '${eventType}' already exists for workflow '${this.workflowId}'.`);
     }
-    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
+    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;
   }
-  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;
+  getEvents() {
+    return this.events;
+  }
+  /**
+   * Saves the ledger events to a JSON file.
+   */
+  async save(filePath) {
+    const targetPath = path3.isAbsolute(filePath) ? filePath : path3.join(this.cwd, filePath);
+    await fs4.mkdir(path3.dirname(targetPath), { recursive: true });
+    for (const event of this.events) {
+      if (event.workflowId !== this.workflowId) {
+        throw new Error(`Ledger workflowId conflict: '${event.workflowId}' does not match '${this.workflowId}'.`);
       }
     }
-    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";
+    const serialized = JSON.stringify(this.events, null, 2);
+    const contentHash = createHash("sha256").update(serialized).digest("hex");
+    const targetExists = await fs4.access(targetPath).then(() => true).catch(() => false);
+    if (targetExists) {
+      const diskHash = createHash("sha256").update(await fs4.readFile(targetPath)).digest("hex");
+      if (this.loadedPath !== targetPath || this.loadedContentHash === null || diskHash !== this.loadedContentHash) {
+        throw new Error(`Ledger changed on disk or was not loaded before update: '${targetPath}'.`);
+      }
+    } else if (this.loadedPath === targetPath && this.loadedContentHash !== null) {
+      throw new Error(`Ledger was removed after it was loaded: '${targetPath}'.`);
     }
-    if (/\b(publish|release|deploy|produção|producao|push to npm|push to remote)\b/i.test(text)) {
-      mutationIntent = "publish";
+    const temporaryPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await fs4.writeFile(temporaryPath, serialized, { encoding: "utf8", flag: "wx" });
+      await fs4.rename(temporaryPath, targetPath);
+      this.loadedPath = targetPath;
+      this.loadedContentHash = contentHash;
+    } catch (error) {
+      await fs4.rm(temporaryPath, { force: true }).catch(() => {
+      });
+      throw error;
     }
-    return mutationIntent;
   }
-  determineRiskAssessment(text, mutationIntent) {
-    const matchedSignals = [];
-    const add = (signal, pattern) => {
-      if (pattern.test(text)) {
-        matchedSignals.push(signal);
-        return true;
+  async load(filePath) {
+    const targetPath = path3.isAbsolute(filePath) ? filePath : path3.join(this.cwd, filePath);
+    try {
+      const content = await fs4.readFile(targetPath, "utf8");
+      const parsed = JSON.parse(content);
+      if (!Array.isArray(parsed) || parsed.some((event) => event.workflowId !== this.workflowId)) {
+        throw new Error(`Ledger is incompatible with workflow '${this.workflowId}'.`);
       }
-      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);
+      this.events = parsed;
+      this.loadedPath = targetPath;
+      this.loadedContentHash = createHash("sha256").update(content).digest("hex");
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.loadedPath = targetPath;
+        this.loadedContentHash = null;
+        return false;
       }
+      throw error;
     }
-    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");
+  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");
     }
-    if (/\b(formal spec|required spec)\b/i.test(text)) {
-      safetyConstraints.push("Require formal specification");
+    const nexusMutates = events.some((e) => e.actor === "Nexus" && e.eventType === "file_mutate");
+    if (nexusMutates) {
+      violations.push("Nexus cannot mutate files during discovery");
     }
-    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"]
-      };
+    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");
     }
-    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.";
+    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");
       }
     }
-    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;
-      });
+    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 {
-      requestedActor,
-      selectedActor,
-      operationType,
-      mutationIntent,
-      permissionDecision,
-      reason,
-      workflowPath
+      passed,
+      status: passed ? "PASS" : "BLOCKED",
+      reason: violations.length > 0 ? `Role violations: ${violations.join("; ")}` : "Verification passed",
+      violations
     };
   }
-  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 {
+// 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;
+  }
   /**
-   * 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.
+   * Logs routing decision by Atlas.
    */
   async route(naturalRequest, classification) {
     const decision = classification.routingDecision ?? {
@@ -1387,6 +955,104 @@ var DelegationController = class {
       });
     }
   }
+  /**
+   * Executes one high-risk phase and fails closed unless the runtime confirms
+   * the requested actor through machine-readable output.
+   */
+  async executePhase({
+    phase,
+    actor,
+    prompt,
+    readOnly,
+    requireExplicitActor = true,
+    onOutput
+  }) {
+    const inspection = await this.adapter.inspect();
+    const supported = inspection.available && inspection.supports?.agent === true;
+    const startType = `${phase}_start`;
+    const completeType = `${phase}_complete`;
+    this.ledger?.logEvent({
+      actor: supported ? actor : "Atlas",
+      actorType: supported ? "runtime-agent" : "control-plane",
+      observed: true,
+      runtime: "opencode",
+      eventType: startType,
+      provenance: "opencode-adapter",
+      data: {
+        phase,
+        runtimeAgentRequested: actor,
+        runtimeAgentApplied: null,
+        runtimeAgentSupported: supported,
+        runtimeAgentSelectionMode: supported ? "explicit" : inspection.available ? "prompt-fallback" : "degraded",
+        runtimeActorConfirmation: "unavailable",
+        readOnly,
+        status: "started"
+      }
+    });
+    let runResult;
+    if (requireExplicitActor && !supported) {
+      runResult = {
+        success: false,
+        status: "BLOCKED",
+        error: "Runtime cannot explicitly select and confirm the requested actor.",
+        commandsRun: [],
+        eventCount: 0,
+        output: "",
+        runtimeAgentRequested: actor,
+        runtimeAgentApplied: null,
+        runtimeAgentSupported: false,
+        runtimeAgentSelectionMode: inspection.available ? "prompt-fallback" : "degraded",
+        runtimeActorConfirmation: "unavailable"
+      };
+    } else {
+      runResult = await this.adapter.execute(prompt, { agent: actor, readOnly, requireActorConfirmation: true });
+    }
+    if (runResult.success && requireExplicitActor) {
+      if (!["explicit", "sdk-session"].includes(runResult.runtimeAgentSelectionMode || "") || runResult.runtimeAgentApplied !== actor || runResult.runtimeActorConfirmation !== "confirmed") {
+        runResult = {
+          ...runResult,
+          success: false,
+          status: "BLOCKED",
+          error: runResult.runtimeAgentApplied ? `Runtime confirmed actor '${runResult.runtimeAgentApplied}', expected '${actor}'.` : `Runtime did not provide machine-readable confirmation for actor '${actor}'.`
+        };
+      }
+    }
+    if (runResult.success && onOutput) {
+      try {
+        const artifact = await onOutput(runResult.output || "");
+        if (artifact) runResult.artifact = artifact;
+      } catch (error) {
+        runResult = {
+          ...runResult,
+          success: false,
+          status: "BLOCKED",
+          error: error.message
+        };
+      }
+    }
+    this.ledger?.logEvent({
+      actor: runResult.runtimeAgentApplied === actor ? actor : "Atlas",
+      actorType: runResult.runtimeAgentApplied === actor ? "runtime-agent" : "control-plane",
+      observed: true,
+      runtime: "opencode",
+      eventType: completeType,
+      provenance: "opencode-adapter",
+      data: {
+        phase,
+        success: runResult.success,
+        error: runResult.error || null,
+        runtimeAgentRequested: runResult.runtimeAgentRequested || actor,
+        runtimeAgentApplied: runResult.runtimeAgentApplied || null,
+        runtimeAgentSupported: runResult.runtimeAgentSupported === true,
+        runtimeAgentSelectionMode: runResult.runtimeAgentSelectionMode || "unsupported",
+        runtimeActorConfirmation: runResult.runtimeActorConfirmation || "unavailable",
+        artifactPath: runResult.artifact?.artifactPath || null,
+        artifactHash: runResult.artifact?.artifactHash || null,
+        status: runResult.success ? "COMPLETED" : "BLOCKED"
+      }
+    });
+    return runResult;
+  }
   /**
    * Logs and executes the implementation process by Astra.
    */
@@ -1500,8 +1166,8 @@ var DelegationController = class {
       }
       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();
+        const { execSync: execSync5 } = await import("child_process");
+        gitDiff = execSync5("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
       } catch {
       }
       const prompt = `Please validate the implementation. Diff:
@@ -1545,10 +1211,10 @@ ${JSON.stringify(result, null, 2)}`;
 };
 
 // src/core/finalization/workspace-snapshot.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs5 from "fs/promises";
+import path4 from "path";
 import crypto2 from "crypto";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 var WorkspaceSnapshot = class {
   cwd;
   fastTrack;
@@ -1575,7 +1241,7 @@ var WorkspaceSnapshot = class {
     }
     const execGit = (args) => {
       try {
-        return execSync4(`git ${args}`, { cwd: this.cwd, encoding: "utf8", stdio: "pipe" }).trim();
+        return execSync3(`git ${args}`, { cwd: this.cwd, encoding: "utf8", stdio: "pipe" }).trim();
       } catch {
         return "";
       }
@@ -1601,10 +1267,10 @@ var WorkspaceSnapshot = class {
   }
   async scanDir(dir, filesMap) {
     try {
-      const entries = await fs7.readdir(dir, { withFileTypes: true });
+      const entries = await fs5.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
-        const relativePath = path7.relative(this.cwd, fullPath);
+        const fullPath = path4.join(dir, entry.name);
+        const relativePath = path4.relative(this.cwd, fullPath);
         if (this.isIgnored(relativePath)) {
           continue;
         }
@@ -1612,8 +1278,8 @@ var WorkspaceSnapshot = class {
           await this.scanDir(fullPath, filesMap);
         } else if (entry.isFile()) {
           try {
-            const stat = await fs7.stat(fullPath);
-            const content = await fs7.readFile(fullPath);
+            const stat = await fs5.stat(fullPath);
+            const content = await fs5.readFile(fullPath);
             const sha256 = crypto2.createHash("sha256").update(content).digest("hex");
             const isExecutable = (stat.mode & 73) !== 0;
             const mode = isExecutable ? "100755" : "100644";
@@ -1647,9 +1313,9 @@ var WorkspaceSnapshot = class {
 };
 
 // src/core/finalization/finalizer.ts
-import { execSync as execSync5 } from "child_process";
-import path8 from "path";
-import fs8 from "fs/promises";
+import { execSync as execSync4 } from "child_process";
+import path5 from "path";
+import fs6 from "fs/promises";
 var Finalizer = class {
   cwd;
   snapshotManager;
@@ -1662,9 +1328,9 @@ var Finalizer = class {
   getChangedFilesFromGit() {
     try {
       const files = /* @__PURE__ */ new Set();
-      const diff = execSync5("git diff --name-only HEAD", { cwd: this.cwd, encoding: "utf8" });
+      const diff = execSync4("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" });
+      const status = execSync4("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) {
@@ -1722,10 +1388,10 @@ var Finalizer = class {
     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);
+    const evidencePath = path5.join(this.cwd, "EVIDENCE.json");
+    const hasEvidence = await fs6.access(evidencePath).then(() => true).catch(() => false);
     if (hasEvidence) {
-      const { EvidenceValidator } = await import("./evidence-validator-76ZQQYDU.js");
+      const { EvidenceValidator } = await import("./evidence-validator-HS3NTWAB.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();
@@ -1736,72 +1402,564 @@ var Finalizer = class {
       }
     }
     return {
-      passed,
-      status: requestFidelity.status || (passed ? "PASS" : "BLOCKED"),
+      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 }
+    };
+  }
+};
+
+// 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 path6 from "path";
+import fs7 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 = path6.join(this.cwd, ".ai-workflow/remediation-request.json");
+      let hasFindings = false;
+      if (fs7.existsSync(requestPath)) {
+        try {
+          const reqData = JSON.parse(fs7.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,
-      deliveryClass: actualDeliveryClass,
-      requestFidelity
+      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 {
   /**
-   * Compares the current workspace state with a previously captured snapshot.
+   * Classifies a natural request.
    */
-  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;
+  classify(request = "", options = {}) {
+    const text = String(request).trim();
+    if (!text) {
+      throw new Error("Cannot classify an empty request.");
     }
-    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);
+    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";
       }
     }
-    for (const file of Object.keys(prevFiles)) {
-      if (!currFiles[file]) {
-        deleted.push(file);
+    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 path7 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 ? path7.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");
       }
     }
-    if (added.length > 0 || modified.length > 0 || deleted.length > 0) {
-      valid = false;
+    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 {
-      valid,
-      changes: { added, modified, deleted }
+      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];
+  }
 };
 
 export {
+  getPackageRoot,
   readPackageFile,
   getPackageVersion,
   discoverPackageFiles,
@@ -1811,17 +1969,16 @@ export {
   isTerminalFailure,
   COMPLETION_STATUS_TEXT,
   OpenCodeAdapter,
-  BranchGate,
   SpecValidator,
   HandoffEngine,
   HealerEngine,
   getWorkflowProfile,
   resolveWorkflowProfile,
-  RequestClassifier,
-  ExecutionPlanner,
-  WorkflowStateMachine,
   EvidenceLedger,
   DelegationController,
-  Finalizer
+  Finalizer,
+  RequestClassifier,
+  ExecutionPlanner,
+  WorkflowStateMachine
 };
-//# sourceMappingURL=chunk-W4RTQWVQ.js.map
+//# sourceMappingURL=chunk-LI76KI7C.js.map