@williambeto/ai-workflow 2.7.1 → 2.8.1

package/{chunk-W4RTQWVQ.js → chunk-4FI5ODAM.js}

@@ -1,7 +1,8 @@
 import {
   ArtifactFidelityGate,
-  DeliveryDecisionEngine
-} from "./chunk-XW747GIG.js";
+  DeliveryDecisionEngine,
+  RequestRouter
+} from "./chunk-H7GIKXFO.js";
 
 // src/core/package-assets.ts
 import { fileURLToPath } from "url";
@@ -94,6 +95,145 @@ 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 buildPromptFallback(agent, message, orchestratedChild = false) {
+  if (agent === "Astra") {
+    return [
+      "You are Atlas, the AI Workflow Kit coordinator running under Atlas permissions.",
+      "Delegate the implementation exactly once to the configured Astra agent using the task tool. Do not edit workspace files yourself and do not pretend to be Astra.",
+      orchestratedChild ? "The parent execute process already owns branch safety, validation, evidence, and finalization. Do not run git branch/status, collect-evidence, handoff, or another execute workflow." : "Keep coordination minimal and let Astra own every requested workspace mutation.",
+      "Ask Astra to make the smallest scoped change and run only proportional validation: docs integrity for docs, a focused behavior test for simple code, and tests plus build for normal React work. Screenshots, README changes, Sage, and Phoenix are conditional, not default.",
+      "Return Astra's observed result without adding a second implementation or finalization pass.",
+      "",
+      "User request:",
+      message
+    ].join("\n");
+  }
+  return `${AGENT_PROMPT_CONTRACTS[agent]}
+
+Runtime agent selection note: requested actor '${agent}' could not be applied with --agent because this OpenCode runtime does not support it. Continue under this bounded prompt contract and preserve all AI Workflow Kit safety rules.
+
+User request:
+${message}`;
+}
+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 commandEvents = commandsRun.map((command) => ({
+    command,
+    tool: "sdk-tool",
+    status: "UNKNOWN",
+    exitCode: null,
+    source: "sdk"
+  }));
+  const appliedAgent = typeof data?.info?.agent === "string" ? data.info.agent : null;
+  const confirmed = appliedAgent === requestedAgent;
+  return {
+    success: !data?.info?.error && confirmed,
+    commandsRun,
+    commandEvents,
+    eventCount: parts.length,
+    runtimeAgentApplied: appliedAgent,
+    runtimeActorConfirmation: confirmed ? "confirmed" : "unavailable",
+    output
+  };
+}
+function extractCommandEvents(event) {
+  const calls = Array.isArray(event?.part?.toolCalls) ? event.part.toolCalls : event?.type === "tool" || event?.type === "tool_use" || event?.type === "tool_result" ? [event.part || event] : [];
+  return calls.flatMap((call) => {
+    const input = call?.args || call?.input || call?.state?.input || call?.part?.state?.input || {};
+    const command = input.command ?? input.CommandLine ?? call?.command;
+    if (typeof command !== "string" || !command.trim()) return [];
+    const rawExit = call?.exitCode ?? call?.output?.exitCode ?? call?.state?.metadata?.exitCode ?? event?.exitCode;
+    const exitCode = typeof rawExit === "number" ? rawExit : null;
+    return [{
+      command: command.trim(),
+      tool: String(call?.name || call?.tool || event?.tool || "command"),
+      status: exitCode === null ? "UNKNOWN" : exitCode === 0 ? "PASS" : "FAIL",
+      exitCode,
+      source: "json-event"
+    }];
+  });
+}
+function extractDelegatedAgents(event) {
+  const calls = Array.isArray(event?.part?.toolCalls) ? event.part.toolCalls : ["tool", "tool_use"].includes(event?.type) ? [event?.part || event] : [];
+  const delegatedAgents = [];
+  for (const call of calls) {
+    const tool = String(call?.name || call?.tool || event?.tool || "").toLowerCase();
+    if (tool !== "task") continue;
+    const input = call?.args || call?.input || call?.state?.input || call?.part?.state?.input || {};
+    const delegated = input.subagent_type ?? input.agent ?? input.subagent ?? input.agentName;
+    if (typeof delegated === "string" && delegated.trim()) delegatedAgents.push(delegated.trim());
+  }
+  return delegatedAgents;
+}
+function countAstraCompletionMarkers(value) {
+  return [...String(value || "").matchAll(/(?:✓|✔).*\bAstra Agent\b/gi)].length;
+}
+var MUTATING_GIT_COMMANDS = /* @__PURE__ */ new Set([
+  "add",
+  "am",
+  "apply",
+  "bisect",
+  "checkout",
+  "cherry-pick",
+  "clean",
+  "clone",
+  "commit",
+  "fetch",
+  "gc",
+  "init",
+  "merge",
+  "mv",
+  "notes",
+  "pull",
+  "push",
+  "rebase",
+  "reset",
+  "restore",
+  "revert",
+  "rm",
+  "stash",
+  "switch",
+  "update-index"
+]);
+function gitCommandIsDestructive(command) {
+  for (const match of command.matchAll(/\bgit\b([^;&|]*)/gi)) {
+    const tokens = match[1].trim().split(/\s+/).filter(Boolean);
+    while (tokens[0]?.startsWith("-")) {
+      const option = tokens.shift();
+      if (["-C", "--git-dir", "--work-tree", "--namespace"].includes(option || "")) tokens.shift();
+    }
+    const subcommand = tokens.shift()?.toLowerCase();
+    if (!subcommand) continue;
+    if (MUTATING_GIT_COMMANDS.has(subcommand)) return true;
+    if (subcommand === "branch") {
+      if (tokens.length === 0) continue;
+      const mutatingBranchFlag = tokens.some(
+        (token) => /^(?:-[dDmMcC]|--(?:delete|move|copy|edit-description|set-upstream-to|unset-upstream))(?:=|$)/.test(token)
+      );
+      if (mutatingBranchFlag) return true;
+      const first = tokens[0];
+      const readOnlyBranchFlag = /^(?:--(?:show-current|list|all|remotes|contains|no-contains|merged|no-merged|points-at|format|sort|column|no-column|color|no-color)(?:=|$)|-[larv](?:$|v$))/.test(first);
+      if (!readOnlyBranchFlag) return true;
+    }
+    if (subcommand === "tag") {
+      if (tokens.length === 0) continue;
+      const first = tokens[0];
+      if (!/^(?:--(?:list|contains|no-contains|merged|no-merged|points-at|format|sort)(?:=|$)|-[ln])/.test(first)) return true;
+    }
+    if (subcommand === "remote" && tokens.length > 0 && !/^(?:-v|--verbose|show|get-url)$/.test(tokens[0])) return true;
+    if (subcommand === "worktree" && tokens[0] !== "list") return true;
+  }
+  return false;
+}
+function isDestructiveCommand(command) {
+  if (/(^|[^<])(?:>>|>)/.test(command)) return true;
+  if (/\b(?:touch|rm|mkdir|cp|mv|chmod|chown|tee)\b/.test(command)) return true;
+  if (/\bsed\b[^;&|]*(?:\s-i[^\s]*|\s--in-place(?:=|\s|$))/.test(command)) return true;
+  if (/\bawk\b[^;&|]*\s-i\s*inplace\b/.test(command)) return true;
+  return gitCommandIsDestructive(command);
+}
 var OpenCodeAdapter = class {
   cwd;
   constructor({ cwd = process.cwd() } = {}) {
@@ -110,13 +250,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 +266,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, orchestratedChild = false } = {}) {
     const inspection = await this.inspect();
     const isSpecializedAgent = agent && ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(agent);
     if (!readOnly) {
@@ -152,6 +293,8 @@ var OpenCodeAdapter = class {
             runtimeAgentApplied: null,
             runtimeAgentSupported: false,
             runtimeAgentSelectionMode: "unsupported",
+            runtimeActorConfirmation: "unavailable",
+            output: "",
             commandsRun: [],
             eventCount: 0
           };
@@ -159,26 +302,103 @@ 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);
-    const runtimeMessage = usePromptFallback ? `${AGENT_PROMPT_CONTRACTS[agent]}
+    const agentMessage = usePromptFallback ? buildPromptFallback(agent, message, orchestratedChild) : message;
+    const runtimeMessage = orchestratedChild ? `${agentMessage}
 
-Runtime agent selection note: requested actor '${agent}' could not be applied with --agent because this OpenCode runtime does not support it. Continue as that actor by prompt contract and preserve all AI Workflow Kit safety rules.
-
-User request:
-${message}` : message;
-    const runtimeAgentSelectionMode = isSpecializedAgent ? usePromptFallback ? "prompt-fallback" : "explicit" : "default";
+AIWK_ORCHESTRATED_CHILD: The parent execute process exclusively owns collect-evidence, handoff, and finalization. Do not invoke those operations or start another execute workflow.` : agentMessage;
+    const runtimeAgentSelectionMode = isSpecializedAgent ? usePromptFallback && agent === "Astra" ? "atlas-delegation-fallback" : 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 previousFinalizationOwner = process.env.AI_WORKFLOW_FINALIZATION_OWNER;
+        if (orchestratedChild) process.env.AI_WORKFLOW_FINALIZATION_OWNER = "execute";
+        let runtime;
+        try {
+          runtime = await createOpencode({ port: 0, timeout: 1e4 });
+        } finally {
+          if (previousFinalizationOwner === void 0) delete process.env.AI_WORKFLOW_FINALIZATION_OWNER;
+          else process.env.AI_WORKFLOW_FINALIZATION_OWNER = previousFinalizationOwner;
+        }
+        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: runtimeMessage }]
+        }, { 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];
@@ -194,6 +414,7 @@ ${message}` : message;
         console.log(`[RUNTIME] Delegating to OpenCode: opencode ${args.map((a) => a.includes(" ") ? `"${a}"` : a).join(" ")}`);
         const child = spawn("opencode", args, {
           cwd: targetCwd,
+          env: orchestratedChild ? { ...process.env, AI_WORKFLOW_FINALIZATION_OWNER: "execute" } : process.env,
           stdio: ["ignore", "pipe", "inherit"]
           // Inherit stderr to show warnings directly
         });
@@ -202,29 +423,65 @@ ${message}` : message;
           terminal: false
         });
         const commandsRun = [];
+        const commandEvents = [];
         let eventCount = 0;
+        let output = "";
+        let confirmedAgent = null;
+        let delegatedAgent = null;
+        let astraTaskInvocations = 0;
+        let astraCompletionMarkers = 0;
         rl.on("line", (line) => {
           const trimmed = line.trim();
           if (!trimmed) return;
           try {
             const event = JSON.parse(trimmed);
             eventCount++;
+            const observedDelegations = extractDelegatedAgents(event);
+            astraTaskInvocations += observedDelegations.filter((value) => value === "Astra").length;
+            if (observedDelegations.includes("Astra")) delegatedAgent = "Astra";
+            for (const observation of extractCommandEvents(event)) {
+              commandEvents.push(observation);
+              if (!commandsRun.includes(observation.command)) commandsRun.push(observation.command);
+            }
+            if (readOnly) {
+              const unsafe = commandEvents.find((item) => isDestructiveCommand(item.command));
+              if (unsafe) {
+                child.kill();
+                resolve2({
+                  success: false,
+                  commandsRun,
+                  commandEvents,
+                  eventCount,
+                  error: `Read-only confinement violation: command '${unsafe.command}' attempted write/modify operation during read-only task.`,
+                  runtimeAgentRequested: agent || null,
+                  runtimeAgentApplied: null,
+                  runtimeAgentSupported: inspection.supports.agent,
+                  runtimeAgentSelectionMode,
+                  runtimeActorConfirmation: confirmedAgent ? "confirmed" : "unavailable",
+                  output
+                });
+                return;
+              }
+            }
+            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;
+              const markers = countAstraCompletionMarkers(event.part.text);
+              astraCompletionMarkers += markers;
+              if (markers > 0) delegatedAgent = "Astra";
             }
             if (event.type === "step_start" && event.part?.toolCalls) {
               for (const call of event.part.toolCalls) {
-                if (call.name === "run_command" && call.args?.CommandLine) {
-                  commandsRun.push(call.args.CommandLine);
-                }
                 if (readOnly) {
                   const name = call.name || "";
                   const isWriteTool = name.startsWith("write_") || name.includes("write") || name.includes("replace") || name.includes("edit") || name.includes("delete") || name.includes("remove");
                   let isDestructiveGit = false;
                   if (name === "run_command" && call.args?.CommandLine) {
                     const cmd = call.args.CommandLine;
-                    const destPattern = /\b(git\s+(commit|add|push|merge|reset|rm|branch|checkout|switch|stash|init)|touch|rm|mkdir|cp|mv|chmod|chown|tee|sed|awk)\b|>>|>/;
-                    if (destPattern.test(cmd)) {
+                    if (isDestructiveCommand(cmd)) {
                       isDestructiveGit = true;
                     }
                   }
@@ -240,7 +497,9 @@ ${message}` : message;
                       runtimeAgentRequested: agent || null,
                       runtimeAgentApplied: usePromptFallback ? null : null,
                       runtimeAgentSupported: inspection.supports.agent,
-                      runtimeAgentSelectionMode
+                      runtimeAgentSelectionMode,
+                      runtimeActorConfirmation: confirmedAgent ? "confirmed" : "unavailable",
+                      output
                     });
                     return;
                   }
@@ -249,18 +508,39 @@ ${message}` : message;
             }
           } catch {
             console.log(trimmed);
+            output += `${trimmed}
+`;
+            const shellCommand = trimmed.match(/^\$\s+(.+)$/)?.[1];
+            if (shellCommand) {
+              const observation = { command: shellCommand, tool: "shell", status: "UNKNOWN", exitCode: null, source: "text-output" };
+              commandEvents.push(observation);
+              if (!commandsRun.includes(shellCommand)) commandsRun.push(shellCommand);
+            }
+            const markers = usePromptFallback && agent === "Astra" ? countAstraCompletionMarkers(trimmed) : 0;
+            if (markers > 0) {
+              astraCompletionMarkers += markers;
+              delegatedAgent = "Astra";
+            }
           }
         });
         child.on("close", (code) => {
           console.log("\n[RUNTIME] OpenCode finished execution.");
+          const fallbackDelegationRequired = usePromptFallback && agent === "Astra";
+          const observedAstraDelegations = astraTaskInvocations > 0 ? astraTaskInvocations : astraCompletionMarkers;
+          const fallbackDelegationConfirmed = !fallbackDelegationRequired || delegatedAgent === "Astra" && observedAstraDelegations === 1;
+          const appliedAgent = fallbackDelegationRequired ? delegatedAgent : isSpecializedAgent ? confirmedAgent : null;
           resolve2({
-            success: code === 0,
+            success: code === 0 && fallbackDelegationConfirmed,
             commandsRun,
+            commandEvents,
             eventCount,
+            error: code === 0 && !fallbackDelegationConfirmed ? `OpenCode fallback requires exactly one observed Atlas-to-Astra delegation; observed ${observedAstraDelegations}.` : void 0,
             runtimeAgentRequested: agent || null,
-            runtimeAgentApplied: isSpecializedAgent && !usePromptFallback ? agent : null,
+            runtimeAgentApplied: appliedAgent,
             runtimeAgentSupported: inspection.supports.agent,
-            runtimeAgentSelectionMode
+            runtimeAgentSelectionMode,
+            runtimeActorConfirmation: appliedAgent ? "confirmed" : "unavailable",
+            output
           });
         });
         child.on("error", (err) => {
@@ -269,176 +549,81 @@ ${message}` : message;
           resolve2({
             success: false,
             commandsRun,
+            commandEvents,
             eventCount: 0,
             error: err.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 +634,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 +649,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 +667,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 +678,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 +688,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 +709,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 +793,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 +813,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 +835,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,562 +941,127 @@ 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", "finalization_completed"]);
+    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";
-    }
-    if (/\b(publish|release|deploy|produção|producao|push to npm|push to remote)\b/i.test(text)) {
-      mutationIntent = "publish";
-    }
-    return mutationIntent;
+    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}'.`);
+    }
+    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;
+    }
   }
-  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");
+  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(bypass|force|direct)\b/i.test(text)) {
-      safetyConstraints.push("Block bypass attempts");
+    const nexusMutates = events.some((e) => e.actor === "Nexus" && e.eventType === "file_mutate");
+    if (nexusMutates) {
+      violations.push("Nexus cannot mutate files during discovery");
     }
-    if (/\b(required evidence|evidence required)\b/i.test(text)) {
-      requiredEvidence.push("user-required-evidence");
-    }
-    if (/\b(formal spec|required spec)\b/i.test(text)) {
-      safetyConstraints.push("Require formal specification");
-    }
-    return { safetyConstraints, requiredEvidence };
-  }
-  /**
-   * Decides the routing decision.
-   */
-  route(understanding) {
-    const { operationType, mutationIntent, rawRequest } = understanding;
-    const requestedActor = void 0;
-    if (/\b(bypass safety|bypass validation|force push|directly to main|push to remote without gate)\b/i.test(rawRequest)) {
-      return {
-        requestedActor,
-        selectedActor: "Atlas",
-        operationType,
-        mutationIntent,
-        permissionDecision: "blocked",
-        reason: "Security block: Attempt to bypass safety or push directly is forbidden.",
-        workflowPath: ["Atlas"]
-      };
-    }
-    let { selectedActor, permissionDecision, reason } = this.evaluateActorPermission(operationType, mutationIntent);
-    let workflowPath = ["Atlas"];
-    if (selectedActor === "Phoenix") {
-      const requestPath = path4.join(this.cwd, ".ai-workflow/remediation-request.json");
-      let hasFindings = false;
-      if (fs5.existsSync(requestPath)) {
-        try {
-          const reqData = JSON.parse(fs5.readFileSync(requestPath, "utf8"));
-          if (reqData.affectedChecks && reqData.affectedChecks.length > 0) {
-            hasFindings = true;
-          }
-        } catch {
-        }
-      }
-      if (!hasFindings) {
-        permissionDecision = "blocked";
-        reason = "Blocked: Phoenix acts only with concrete findings and bounded remediation.";
-      }
-    }
-    if (understanding.specPolicy === "required") {
-      workflowPath.push("Nexus", "Orion");
-    }
-    if (selectedActor && !workflowPath.includes(selectedActor)) {
-      workflowPath.push(selectedActor);
-    }
-    if (selectedActor === "Atlas" && ["discover", "validate", "fix", "release", "deploy"].includes(operationType)) {
-      permissionDecision = "blocked";
-      reason = "Atlas self-execution guard: Atlas cannot silently execute specialized actor or capability requests.";
-    }
-    if (selectedActor === "Astra" && understanding.riskLevel === "high") {
-      workflowPath.push("Sage", "Phoenix", "Sage");
-    }
-    if (understanding.specPolicy === "none") {
-      workflowPath = workflowPath.filter((actor) => {
-        if (actor === "Nexus" && selectedActor !== "Nexus") return false;
-        if (actor === "Orion" && selectedActor !== "Orion") return false;
-        return true;
-      });
-    }
-    return {
-      requestedActor,
-      selectedActor,
-      operationType,
-      mutationIntent,
-      permissionDecision,
-      reason,
-      workflowPath
-    };
-  }
-  evaluateActorPermission(operationType, mutationIntent) {
-    let selectedActor;
-    let permissionDecision = "allowed";
-    let reason = "Routed successfully.";
-    if (operationType === "discover") {
-      selectedActor = "Nexus";
-    } else if (operationType === "validate") {
-      selectedActor = "Sage";
-    } else if (operationType === "fix") {
-      selectedActor = "Phoenix";
-    } else if (operationType === "implement") {
-      selectedActor = "Astra";
-    } else if (operationType === "release" || operationType === "deploy") {
-      selectedActor = "Orion";
-    } else {
-      selectedActor = mutationIntent === "write" ? "Astra" : "Atlas";
-    }
-    return { selectedActor, permissionDecision, reason };
-  }
-};
-
-// src/core/request-classifier.ts
-var RequestClassifier = class {
-  /**
-   * Classifies a natural request.
-   */
-  classify(request = "", options = {}) {
-    const text = String(request).trim();
-    if (!text) {
-      throw new Error("Cannot classify an empty request.");
-    }
-    const cwd = options.cwd || process.cwd();
-    const profile = resolveWorkflowProfile({ request: text });
-    const profileDef = getWorkflowProfile(profile);
-    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify)\b/i;
-    const isReadOnly = readOnlyPatterns.test(text);
-    const intent = isReadOnly ? "read-only" : "write";
-    const router = new RequestRouter({ cwd });
-    const requestUnderstanding = router.understand(text);
-    const routingDecision = router.route(requestUnderstanding);
-    const risk = requestUnderstanding.riskLevel;
-    const explicitRequiredEvidence = /\b(required evidence|evidence required)\b/i.test(text);
-    const explicitRequiredSpec = /\b(formal spec|required spec)\b/i.test(text);
-    const specPolicy = requestUnderstanding.specPolicy === "required" || explicitRequiredSpec ? "required" : "none";
-    const evidencePolicy = risk === "high" || requestUnderstanding.mutationIntent === "publish" || explicitRequiredEvidence ? "required" : "optional";
-    const remediationLimit = risk === "high" ? 3 : risk === "low" ? 1 : 2;
-    const specNeeded = specPolicy === "required";
-    const validationNeeded = intent === "write";
-    let legacyMode = "standard";
-    if (/\b(deep|architectural|migration|major|full|\[deep\])\b/i.test(text)) {
-      legacyMode = "full";
-    } else if (/\b(tiny|small|quick|simple|only\s+update|typo|comment|\[tiny\])\b/i.test(text)) {
-      const isPureDocsOrTypo = profile === "documentation" || /\b(typo|comment|readme|docs|documentation)\b/i.test(text);
-      if (intent === "write" && !isPureDocsOrTypo) {
-        legacyMode = "standard";
-      } else {
-        legacyMode = "quick";
-      }
-    }
-    return {
-      request: text,
-      profile,
-      owner: routingDecision.selectedActor || profileDef.owner,
-      intent: requestUnderstanding.mutationIntent === "readonly" ? "read-only" : "write",
-      mode: legacyMode,
-      risk,
-      specPolicy,
-      evidencePolicy,
-      remediationLimit,
-      riskDrivers: requestUnderstanding.riskDrivers || [],
-      matchedSignals: requestUnderstanding.matchedSignals || [],
-      specNeeded,
-      validationNeeded,
-      skills: [...profileDef.skills],
-      requestUnderstanding,
-      routingDecision
-    };
-  }
-};
-
-// src/core/execution-planner.ts
-import path5 from "path";
-var ExecutionPlanner = class {
-  cwd;
-  constructor({ cwd = process.cwd() } = {}) {
-    this.cwd = cwd;
-  }
-  /**
-   * Generates an execution plan.
-   */
-  plan(classification, taskSlug = "task") {
-    const remediationLimit = classification.remediationLimit;
-    const branchNeeded = classification.intent === "write";
-    const specPath = classification.specNeeded ? path5.join("docs/workflows", taskSlug, "spec.md") : null;
-    const owner = classification.routingDecision?.selectedActor || (classification.intent === "write" ? "Astra" : classification.owner);
-    const validationsExpected = [];
-    if (classification.validationNeeded) {
-      validationsExpected.push("test");
-      if (classification.profile.startsWith("frontend")) {
-        validationsExpected.push("lint", "build");
-      } else if (classification.profile === "backend-api") {
-        validationsExpected.push("lint");
-      }
-    }
-    const restrictions = [
-      "Never commit or push directly to main/master.",
-      "Always execute behavior tests for new or modified behavior."
-    ];
-    if (classification.risk === "high") {
-      restrictions.push("Require independent validation review.");
-    }
-    return {
-      objective: classification.request,
-      scope: classification.intent === "read-only" ? "Analysis and verification" : "Implementation of requested behavior",
-      restrictions,
-      owner,
-      skills: [...classification.skills],
-      branchNeeded,
-      branchName: branchNeeded ? `feat/${taskSlug}` : null,
-      validationsExpected,
-      remediationLimit,
-      specPath,
-      specPolicy: classification.specPolicy,
-      evidencePolicy: classification.evidencePolicy,
-      riskLevel: classification.risk,
-      mode: classification.mode,
-      profile: classification.profile
-    };
-  }
-};
-
-// src/core/workflow-state-machine.ts
-var WorkflowStateMachine = class {
-  state;
-  history;
-  validTransitions;
-  constructor() {
-    this.state = "RECEIVED";
-    this.history = [{ state: this.state, timestamp: (/* @__PURE__ */ new Date()).toISOString() }];
-    this.validTransitions = {
-      RECEIVED: ["CLASSIFIED", "BLOCKED"],
-      CLASSIFIED: ["PLANNED", "BLOCKED"],
-      PLANNED: ["BRANCH_READY", "BLOCKED"],
-      BRANCH_READY: ["DELEGATED", "BLOCKED"],
-      DELEGATED: ["IMPLEMENTING", "BLOCKED"],
-      IMPLEMENTING: ["IMPLEMENTED", "BLOCKED"],
-      IMPLEMENTED: ["VALIDATING", "BLOCKED"],
-      VALIDATING: ["COMPLETED", "COMPLETED_WITH_NOTES", "REMEDIATING", "BLOCKED"],
-      REMEDIATING: ["REVALIDATING", "BLOCKED"],
-      REVALIDATING: ["COMPLETED", "COMPLETED_WITH_NOTES", "REMEDIATING", "BLOCKED"],
-      COMPLETED: [],
-      COMPLETED_WITH_NOTES: [],
-      BLOCKED: []
-    };
-  }
-  /**
-   * Transitions the machine to a new state.
-   * @param newState - The state to transition to.
-   */
-  transitionTo(newState) {
-    const allowed = this.validTransitions[this.state];
-    if (!allowed || !allowed.includes(newState)) {
-      throw new Error(`Invalid state transition: ${this.state} -> ${newState}`);
-    }
-    this.state = newState;
-    this.history.push({ state: this.state, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-  getCurrentState() {
-    return this.state;
-  }
-  getHistory() {
-    return [...this.history];
-  }
-};
-
-// src/core/evidence/evidence-ledger.ts
-import fs6 from "fs/promises";
-import path6 from "path";
-var EvidenceLedger = class {
-  cwd;
-  workflowId;
-  events;
-  constructor({ cwd = process.cwd(), workflowId = "unknown" } = {}) {
-    this.cwd = cwd;
-    this.workflowId = workflowId;
-    this.events = [];
-  }
-  /**
-   * Logs a workflow event to the ledger.
-   */
-  logEvent({
-    actor,
-    eventType,
-    provenance,
-    data = {},
-    actorType,
-    observed,
-    runtime
-  }) {
-    const event = {
-      workflowId: this.workflowId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      actor,
-      actorType: actorType !== void 0 ? actorType : void 0,
-      observed: observed !== void 0 ? observed : void 0,
-      runtime: runtime !== void 0 ? runtime : void 0,
-      eventType,
-      provenance,
-      data
-    };
-    this.events.push(event);
-    console.log(`[LEDGER] [${actor}] ${eventType}: ${JSON.stringify(data)}`);
-    return event;
-  }
-  getEvents() {
-    return this.events;
-  }
-  /**
-   * Saves the ledger events to a JSON file.
-   */
-  async save(filePath) {
-    const targetPath = path6.isAbsolute(filePath) ? filePath : path6.join(this.cwd, filePath);
-    await fs6.mkdir(path6.dirname(targetPath), { recursive: true });
-    await fs6.writeFile(targetPath, JSON.stringify(this.events, null, 2), "utf8");
-  }
-  async verifyRoleConfinement() {
-    const violations = [];
-    const events = this.events;
-    const atlasImplements = events.some((e) => e.actor === "Atlas" && (e.eventType === "implementation_start" || e.eventType === "implementation_complete"));
-    if (atlasImplements) {
-      violations.push("Atlas cannot implement directly");
-    }
-    const nexusMutates = events.some((e) => e.actor === "Nexus" && e.eventType === "file_mutate");
-    if (nexusMutates) {
-      violations.push("Nexus cannot mutate files during discovery");
-    }
-    const sageValidates = events.some((e) => e.actor === "Sage" && (e.eventType === "validation_start" || e.eventType === "validation_complete"));
-    const hasFidelity = events.some((e) => e.eventType === "fidelity_check" || e.eventType === "fidelity_verification");
-    if (sageValidates && !hasFidelity) {
-      violations.push("Sage cannot validate without fidelity evidence");
+    const 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) {
@@ -1387,6 +1137,106 @@ 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, orchestratedChild: 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,
+        commandsRun: runResult.commandsRun || [],
+        commandEvents: runResult.commandEvents || [],
+        status: runResult.success ? "COMPLETED" : "BLOCKED"
+      }
+    });
+    return runResult;
+  }
   /**
    * Logs and executes the implementation process by Astra.
    */
@@ -1394,6 +1244,9 @@ var DelegationController = class {
     const decision = this.lastRoutingDecision ?? {
       operationType: "explain",
       mutationIntent: "readonly",
+      deliveryMode: "answer-only",
+      mutationOwner: null,
+      capabilityRoles: [],
       permissionDecision: "allowed",
       reason: "no routing decision",
       workflowPath: []
@@ -1440,6 +1293,7 @@ var DelegationController = class {
         data: {
           success: runResult.success,
           commandsRun: runResult.commandsRun || [],
+          commandEvents: runResult.commandEvents || [],
           eventCount: runResult.eventCount || 0,
           error: runResult.error,
           event: "implementation.completed",
@@ -1467,6 +1321,9 @@ var DelegationController = class {
       const decision = this.lastRoutingDecision ?? {
         operationType: "explain",
         mutationIntent: "readonly",
+        deliveryMode: "answer-only",
+        mutationOwner: null,
+        capabilityRoles: [],
         permissionDecision: "allowed",
         reason: "no routing decision",
         workflowPath: []
@@ -1500,8 +1357,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 +1402,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 { execFileSync, execSync as execSync3 } from "child_process";
 var WorkspaceSnapshot = class {
   cwd;
   fastTrack;
@@ -1571,11 +1428,16 @@ var WorkspaceSnapshot = class {
     const files = {};
     const isTest = process.env.NODE_ENV === "test" || process.env.VITEST === "true";
     if (!this.fastTrack || isTest) {
-      await this.scanDir(this.cwd, files);
+      const gitVisibleFiles = this.listGitVisibleFiles();
+      if (gitVisibleFiles) {
+        await this.scanFiles(gitVisibleFiles, files);
+      } else {
+        await this.scanDir(this.cwd, files);
+      }
     }
     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 "";
       }
@@ -1599,12 +1461,46 @@ var WorkspaceSnapshot = class {
       untrackedFilesHash: hashString(untrackedFiles)
     };
   }
+  listGitVisibleFiles() {
+    try {
+      execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+        cwd: this.cwd,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      const output = execFileSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+        cwd: this.cwd,
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      return [...new Set(output.split("\0").filter(Boolean))];
+    } catch {
+      return null;
+    }
+  }
+  async scanFiles(relativePaths, filesMap) {
+    for (const relativePath of relativePaths) {
+      const normalizedPath = relativePath.replaceAll("\\", "/");
+      if (this.isIgnored(normalizedPath)) continue;
+      try {
+        const fullPath = path4.join(this.cwd, relativePath);
+        const stat = await fs5.stat(fullPath);
+        if (!stat.isFile()) continue;
+        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";
+        filesMap[normalizedPath] = { sha256, mode };
+      } catch {
+      }
+    }
+  }
   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 +1508,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 +1543,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 +1558,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 +1618,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();
@@ -1801,7 +1697,232 @@ var Finalizer = 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-classifier.ts
+var RequestClassifier = class {
+  /**
+   * Classifies a natural request.
+   */
+  classify(request = "", options = {}) {
+    const text = String(request).trim();
+    if (!text) {
+      throw new Error("Cannot classify an empty request.");
+    }
+    const cwd = options.cwd || process.cwd();
+    const profile = resolveWorkflowProfile({ request: text });
+    const profileDef = getWorkflowProfile(profile);
+    const router = new RequestRouter({ cwd });
+    const requestUnderstanding = router.understand(text);
+    const routingDecision = router.route(requestUnderstanding);
+    const intent = requestUnderstanding.mutationIntent === "readonly" || requestUnderstanding.deliveryMode === "answer-only" ? "read-only" : "write";
+    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,
+      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 path6 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 ? path6.join("docs/workflows", taskSlug, "spec.md") : null;
+    const owner = classification.routingDecision?.mutationOwner === "Astra" ? "Astra" : 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];
+  }
+};
+
 export {
+  getPackageRoot,
   readPackageFile,
   getPackageVersion,
   discoverPackageFiles,
@@ -1811,17 +1932,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-4FI5ODAM.js.map