@williambeto/ai-workflow 2.8.0 → 2.8.2

package/{chunk-LI76KI7C.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,21 +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() } = {}) {
@@ -148,7 +273,7 @@ var OpenCodeAdapter = class {
   /**
    * Runs opencode with a prompt and options.
    */
-  async execute(message, { agent = null, model = null, readOnly = false, fastTrack = false, requireActorConfirmation = 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) {
@@ -194,13 +319,11 @@ var OpenCodeAdapter = class {
       };
     }
     const usePromptFallback = Boolean(isSpecializedAgent && !inspection.supports.agent && agent);
-    const runtimeMessage = usePromptFallback ? `${AGENT_PROMPT_CONTRACTS[agent]}
-
-Runtime agent selection note: requested actor '${agent}' could not be applied with --agent because this OpenCode runtime does not support it. Continue as that actor by prompt contract and preserve all AI Workflow Kit safety rules.
+    const agentMessage = usePromptFallback ? buildPromptFallback(agent, message, orchestratedChild) : message;
+    const runtimeMessage = orchestratedChild ? `${agentMessage}
 
-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 {
@@ -220,7 +343,15 @@ ${message}` : message;
       let server;
       try {
         const { createOpencode } = await import("@opencode-ai/sdk/v2");
-        const runtime = await createOpencode({ port: 0, timeout: 1e4 });
+        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" },
@@ -238,7 +369,7 @@ ${message}` : message;
           sessionID: session.data.id,
           directory: targetCwd,
           agent,
-          parts: [{ type: "text", text: message }]
+          parts: [{ type: "text", text: runtimeMessage }]
         }, { throwOnError: true });
         const extracted = extractSdkExecution(response.data, agent);
         if (extracted.output) process.stdout.write(extracted.output);
@@ -283,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
         });
@@ -291,35 +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;
                     }
                   }
@@ -346,19 +508,38 @@ ${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 ? confirmedAgent : null,
+            runtimeAgentApplied: appliedAgent,
             runtimeAgentSupported: inspection.supports.agent,
             runtimeAgentSelectionMode,
-            runtimeActorConfirmation: confirmedAgent ? "confirmed" : "unavailable",
+            runtimeActorConfirmation: appliedAgent ? "confirmed" : "unavailable",
             output
           });
         });
@@ -368,6 +549,7 @@ ${message}` : message;
           resolve2({
             success: false,
             commandsRun,
+            commandEvents,
             eventCount: 0,
             error: err.message,
             runtimeAgentRequested: agent || null,
@@ -788,7 +970,7 @@ var EvidenceLedger = class {
     observed,
     runtime
   }) {
-    const uniqueTerminalEvents = /* @__PURE__ */ new Set(["specification_complete", "planning_complete", "implementation_complete"]);
+    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}'.`);
     }
@@ -1005,7 +1187,7 @@ var DelegationController = class {
         runtimeActorConfirmation: "unavailable"
       };
     } else {
-      runResult = await this.adapter.execute(prompt, { agent: actor, readOnly, requireActorConfirmation: true });
+      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") {
@@ -1048,6 +1230,8 @@ var DelegationController = class {
         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"
       }
     });
@@ -1060,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: []
@@ -1106,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",
@@ -1133,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: []
@@ -1214,7 +1405,7 @@ ${JSON.stringify(result, null, 2)}`;
 import fs5 from "fs/promises";
 import path4 from "path";
 import crypto2 from "crypto";
-import { execSync as execSync3 } from "child_process";
+import { execFileSync, execSync as execSync3 } from "child_process";
 var WorkspaceSnapshot = class {
   cwd;
   fastTrack;
@@ -1237,7 +1428,12 @@ 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 {
@@ -1265,6 +1461,40 @@ 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 fs5.readdir(dir, { withFileTypes: true });
@@ -1539,271 +1769,6 @@ function resolveWorkflowProfile({ request = "", explicitProfile = null } = {}) {
   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,
-      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 {
   /**
@@ -1817,12 +1782,10 @@ var RequestClassifier = class {
     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 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);
@@ -1846,7 +1809,7 @@ var RequestClassifier = class {
       request: text,
       profile,
       owner: routingDecision.selectedActor || profileDef.owner,
-      intent: requestUnderstanding.mutationIntent === "readonly" ? "read-only" : "write",
+      intent,
       mode: legacyMode,
       risk,
       specPolicy,
@@ -1864,7 +1827,7 @@ var RequestClassifier = class {
 };
 
 // src/core/execution-planner.ts
-import path7 from "path";
+import path6 from "path";
 var ExecutionPlanner = class {
   cwd;
   constructor({ cwd = process.cwd() } = {}) {
@@ -1876,8 +1839,8 @@ var ExecutionPlanner = class {
   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 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");
@@ -1981,4 +1944,4 @@ export {
   ExecutionPlanner,
   WorkflowStateMachine
 };
-//# sourceMappingURL=chunk-LI76KI7C.js.map
+//# sourceMappingURL=chunk-4FI5ODAM.js.map