@williambeto/ai-workflow 2.3.0 → 2.3.2

package/src/commands/execute.js

@@ -125,12 +125,21 @@ export async function runExecute({ cwd, naturalRequest, taskSlug: taskSlugOverri
 
     // 1. Classification
     const classifier = new RequestClassifier();
-    const classification = classifier.classify(naturalRequest);
+    const classification = classifier.classify(naturalRequest, { cwd });
     console.log(`[CLASSIFIED] Intent: ${classification.intent}, Mode: ${classification.mode}, Profile: ${classification.profile}`);
     stateMachine.transitionTo("CLASSIFIED");
 
     await delegationController.route(naturalRequest, classification);
 
+    const routingDecision = classification.routingDecision || {};
+    if (routingDecision.permissionDecision === "blocked") {
+      stateMachine.transitionTo("BLOCKED");
+      throw new Error(`[ROUTE BLOCKED] ${routingDecision.reason}`);
+    }
+    if (routingDecision.permissionDecision === "rerouted") {
+      console.log(`[REROUTED] ${routingDecision.reason}`);
+    }
+
     // 2. Planning
     const planner = new ExecutionPlanner({ cwd });
     plan = planner.plan(classification, taskSlug);

package/src/core/delegation-controller.js

@@ -14,6 +14,9 @@ export class DelegationController {
    * Logs routing decision by Atlas.
    */
   async route(naturalRequest, classification) {
+    const decision = classification.routingDecision || {};
+    this.lastRoutingDecision = decision;
+
     if (this.ledger) {
       this.ledger.logEvent({
         actor: "Atlas",
@@ -23,8 +26,19 @@ export class DelegationController {
         provenance: "request-classifier",
         data: {
           request: naturalRequest,
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          operationType: decision.operationType || null,
+          mutationIntent: decision.mutationIntent || null,
+          permissionDecision: decision.permissionDecision || null,
+          reason: decision.reason || null,
+          workflowPath: decision.workflowPath || [],
           classification,
-          event: "routing.completed"
+          event: "routing.completed",
+          runtimeAgentRequested: null,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: false,
+          status: decision.permissionDecision === "blocked" ? "BLOCKED" : "COMPLETED"
         }
       });
     }
@@ -34,10 +48,16 @@ export class DelegationController {
    * Logs and executes the implementation process by Astra.
    */
   async implement(promptMsg, owner, options = {}) {
+    const decision = this.lastRoutingDecision || {};
+    const inspection = await this.adapter.inspect();
+    const isSpecialized = ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(owner);
+    const supportsAgent = inspection.supports?.agent;
+    const canApply = !isSpecialized || supportsAgent;
+
     if (this.ledger) {
       this.ledger.logEvent({
-        actor: owner,
-        actorType: "runtime-agent",
+        actor: canApply ? owner : "Atlas",
+        actorType: canApply ? "runtime-agent" : "control-plane",
         observed: true,
         runtime: "opencode",
         eventType: "implementation_start",
@@ -45,7 +65,15 @@ export class DelegationController {
         data: {
           agent: owner,
           prompt: promptMsg,
-          event: "implementation.started"
+          event: "implementation.started",
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          runtimeAgentRequested: owner,
+          runtimeAgentApplied: null,
+          runtimeAgentSupported: supportsAgent || false,
+          permissionDecision: decision.permissionDecision || null,
+          reason: decision.reason || null,
+          status: "started"
         }
       });
     }
@@ -53,9 +81,10 @@ export class DelegationController {
     const runResult = await this.adapter.execute(promptMsg, { agent: owner, ...options });
 
     if (this.ledger) {
+      const isApplied = runResult.runtimeAgentApplied === owner;
       this.ledger.logEvent({
-        actor: owner,
-        actorType: "runtime-agent",
+        actor: isApplied ? owner : "Atlas",
+        actorType: isApplied ? "runtime-agent" : "control-plane",
         observed: true,
         runtime: "opencode",
         eventType: "implementation_complete",
@@ -65,7 +94,15 @@ export class DelegationController {
           commandsRun: runResult.commandsRun || [],
           eventCount: runResult.eventCount || 0,
           error: runResult.error,
-          event: "implementation.completed"
+          event: "implementation.completed",
+          requestedActor: decision.requestedActor || null,
+          selectedActor: decision.selectedActor || null,
+          runtimeAgentRequested: runResult.runtimeAgentRequested || owner || null,
+          runtimeAgentApplied: runResult.runtimeAgentApplied || null,
+          runtimeAgentSupported: runResult.runtimeAgentSupported !== undefined ? runResult.runtimeAgentSupported : (supportsAgent || false),
+          permissionDecision: decision.permissionDecision || null,
+          reason: runResult.error || decision.reason || null,
+          status: runResult.status || (runResult.success ? "COMPLETED" : "FAILED")
         }
       });
     }
@@ -80,17 +117,30 @@ export class DelegationController {
     const result = await verifyFn();
 
     if (mode === "full") {
+      const decision = this.lastRoutingDecision || {};
+      const inspection = await this.adapter.inspect();
+      const supportsAgent = inspection.supports?.agent;
+      const canApply = supportsAgent;
+
       if (this.ledger) {
         this.ledger.logEvent({
-          actor: "Sage",
-          actorType: "auditor",
+          actor: canApply ? "Sage" : "Atlas",
+          actorType: canApply ? "auditor" : "control-plane",
           observed: true,
           runtime: "opencode",
           eventType: "validation_start",
           provenance: "opencode-adapter",
           data: {
             agent: "Sage",
-            event: "validation.started"
+            event: "validation.started",
+            requestedActor: decision.requestedActor || null,
+            selectedActor: decision.selectedActor || null,
+            runtimeAgentRequested: "Sage",
+            runtimeAgentApplied: null,
+            runtimeAgentSupported: supportsAgent || false,
+            permissionDecision: decision.permissionDecision || null,
+            reason: decision.reason || null,
+            status: "started"
           }
         });
       }
@@ -107,9 +157,10 @@ export class DelegationController {
       const runResult = await this.adapter.execute(prompt, { agent: "Sage" });
 
       if (this.ledger) {
+        const isApplied = runResult.runtimeAgentApplied === "Sage";
         this.ledger.logEvent({
-          actor: "Sage",
-          actorType: "auditor",
+          actor: isApplied ? "Sage" : "Atlas",
+          actorType: isApplied ? "auditor" : "control-plane",
           observed: true,
           runtime: "opencode",
           eventType: "validation_complete",
@@ -119,7 +170,15 @@ export class DelegationController {
             commandsRun: runResult.commandsRun || [],
             eventCount: runResult.eventCount || 0,
             error: runResult.error,
-            event: "validation.completed"
+            event: "validation.completed",
+            requestedActor: decision.requestedActor || null,
+            selectedActor: decision.selectedActor || null,
+            runtimeAgentRequested: runResult.runtimeAgentRequested || "Sage",
+            runtimeAgentApplied: runResult.runtimeAgentApplied || null,
+            runtimeAgentSupported: runResult.runtimeAgentSupported !== undefined ? runResult.runtimeAgentSupported : (supportsAgent || false),
+            permissionDecision: decision.permissionDecision || null,
+            reason: runResult.error || decision.reason || null,
+            status: runResult.status || (runResult.success ? "COMPLETED" : "FAILED")
           }
         });
       }

package/src/core/execution-planner.js

@@ -21,9 +21,8 @@ export class ExecutionPlanner {
       ? path.join("docs/workflows", taskSlug, "spec.md")
       : null;
 
-    const owner = classification.intent === "write"
-      ? "Astra"
-      : classification.owner;
+    const owner = classification.routingDecision?.selectedActor ||
+      (classification.intent === "write" ? "Astra" : classification.owner);
 
     // Build default expected validations based on the resolved profile
     const validationsExpected = [];

package/src/core/request-classifier.js

@@ -1,4 +1,5 @@
 import { resolveWorkflowProfile, getWorkflowProfile } from "./workflow-profiles.js";
+import { RequestRouter } from "./request-router.js";
 
 /**
  * RequestClassifier - Classifies natural requests into structured, testable contracts.
@@ -9,12 +10,14 @@ export class RequestClassifier {
    * @param {string} request - The natural language request string.
    * @returns {Object} Structured classification contract.
    */
-  classify(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();
+
     // 1. Resolve Profile
     const profile = resolveWorkflowProfile({ request: text });
     const profileDef = getWorkflowProfile(profile);
@@ -43,16 +46,23 @@ export class RequestClassifier {
     const specNeeded = mode === "full" && intent === "write";
     const validationNeeded = intent === "write";
 
+    // Integrate central RequestRouter
+    const router = new RequestRouter({ cwd });
+    const requestUnderstanding = router.understand(text);
+    const routingDecision = router.route(requestUnderstanding);
+
     return {
       request: text,
       profile,
-      owner: profileDef.owner,
-      intent,
+      owner: routingDecision.selectedActor || profileDef.owner,
+      intent: requestUnderstanding.mutationIntent === "readonly" ? "read-only" : "write",
       mode,
-      risk,
+      risk: requestUnderstanding.riskLevel,
       specNeeded,
       validationNeeded,
-      skills: [...profileDef.skills]
+      skills: [...profileDef.skills],
+      requestUnderstanding,
+      routingDecision
     };
   }
 }

package/src/core/request-router.js

@@ -0,0 +1,289 @@
+import path from "node:path";
+import fs from "node:fs";
+
+export class RequestRouter {
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+    this.validActors = ["Atlas", "Nexus", "Orion", "Astra", "Sage", "Phoenix"];
+  }
+
+  /**
+   * Understands and classifies a natural language request.
+   * @param {string} request 
+   * @returns {Object} RequestUnderstanding
+   */
+  understand(request) {
+    const text = String(request).trim();
+    if (!text) {
+      throw new Error("Cannot classify an empty request.");
+    }
+
+    // 1. Extract requested actor
+    let requestedActor = undefined;
+    let invalidActor = undefined;
+
+    // Direct addressing/reference pattern e.g., "Nexus, discover...", "ask Sage to..."
+    const askMatch = text.match(/\b(?:ask|use|tell|run|agent|actor)\s+([a-zA-Z]+)\b/i);
+    const addressMatch = text.match(/\b([a-zA-Z]+)\s*(?:,)/);
+
+    let candidate = null;
+    if (askMatch) {
+      candidate = askMatch[1];
+    } else if (addressMatch) {
+      candidate = addressMatch[1];
+    } else {
+      // General match for known actors
+      const knownMatch = text.match(/\b(Atlas|Nexus|Orion|Astra|Sage|Phoenix)\b/i);
+      if (knownMatch) {
+        candidate = knownMatch[1];
+      }
+    }
+
+    if (candidate) {
+      const normalized = candidate.charAt(0).toUpperCase() + candidate.slice(1).toLowerCase();
+      if (this.validActors.includes(normalized)) {
+        requestedActor = normalized;
+      } else {
+        invalidActor = candidate;
+      }
+    }
+
+    // 2. Extract operationType and requestedCapability
+    let operationType = "explain"; // default
+    let requestedCapability = undefined;
+
+    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|build|create|add|develop|write|change|modify)\b/i },
+      { op: "fix", pattern: /\b(fix|repair|correct|heal|solve|remediate)\b/i },
+      { op: "release", pattern: /\b(release|tag|prepare release)\b/i },
+      { op: "deploy", pattern: /\b(deploy|publish|push)\b/i }
+    ];
+
+    for (const mapping of capabilityMappings) {
+      const match = text.match(mapping.pattern);
+      if (match) {
+        operationType = mapping.op;
+        requestedCapability = match[1];
+        break;
+      }
+    }
+
+    // 3. Determine mutationIntent
+    const writePatterns = /\b(implement|build|fix|write|change|modify|create|add|refactor|update)\b/i;
+    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify|validate|discover|map)\b/i;
+    
+    let mutationIntent = "write"; // default
+    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|push to npm|push to remote)\b/i.test(text)) {
+      mutationIntent = "publish";
+    }
+
+    // Determine Mode (needed for riskLevel mapping)
+    let mode = "standard";
+    if (/\b(deep|architectural|migration|major|full|\[deep\])\b/i.test(text)) {
+      mode = "full";
+    } else if (/\b(tiny|small|quick|simple|only\s+update|typo|comment|\[tiny\])\b/i.test(text)) {
+      mode = "quick";
+    }
+
+    // 4. Determine riskLevel
+    let riskLevel = "medium";
+    if (mode === "full" || mutationIntent === "publish" || /\b(bypass|force|direct)\b/i.test(text)) {
+      riskLevel = "high";
+    } else if (mode === "quick" || mutationIntent === "readonly") {
+      riskLevel = "low";
+    }
+
+    // 5. safetyConstraints and requiredEvidence
+    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");
+    }
+
+    return {
+      rawRequest: text,
+      taskGoal: `Perform ${operationType} operation under ${mutationIntent} intent`,
+      requestedActor,
+      invalidActor,
+      requestedCapability,
+      operationType,
+      mutationIntent,
+      riskLevel,
+      requiredEvidence,
+      safetyConstraints
+    };
+  }
+
+  /**
+   * Decides the routing decision.
+   * @param {Object} understanding - RequestUnderstanding
+   * @returns {Object} RoutingDecision
+   */
+  route(understanding) {
+    const { requestedActor, invalidActor, operationType, mutationIntent, rawRequest } = understanding;
+
+    // 1. Check for bypass safety attempts
+    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"]
+      };
+    }
+
+    // 2. Check for invalid/ambiguous actor names in critical actions
+    if (invalidActor) {
+      if (["release", "deploy", "fix", "implement"].includes(operationType) || mutationIntent === "publish") {
+        return {
+          requestedActor: undefined,
+          selectedActor: "Atlas",
+          operationType,
+          mutationIntent,
+          permissionDecision: "blocked",
+          reason: `Security block: Request mentions invalid/unrecognized actor '${invalidActor}' for a critical operation.`,
+          workflowPath: ["Atlas"]
+        };
+      }
+    }
+
+    // 3. Permission matrix check
+    const PERMISSION_MATRIX = {
+      Atlas: {
+        allowedOperations: ["explain"],
+        allowedMutations: ["readonly"]
+      },
+      Nexus: {
+        allowedOperations: ["discover", "explain", "plan"],
+        allowedMutations: ["readonly", "write"]
+      },
+      Orion: {
+        allowedOperations: ["plan", "release", "deploy"],
+        allowedMutations: ["readonly", "write", "publish"]
+      },
+      Astra: {
+        allowedOperations: ["implement", "fix", "explain"],
+        allowedMutations: ["readonly", "write"]
+      },
+      Sage: {
+        allowedOperations: ["validate", "explain"],
+        allowedMutations: ["readonly"]
+      },
+      Phoenix: {
+        allowedOperations: ["fix"],
+        allowedMutations: ["readonly", "write"]
+      }
+    };
+
+    let selectedActor = undefined;
+    let permissionDecision = "allowed";
+    let reason = "Routed successfully.";
+    let workflowPath = ["Atlas"];
+
+    if (requestedActor) {
+      const perms = PERMISSION_MATRIX[requestedActor];
+      const isOpAllowed = perms.allowedOperations.includes(operationType);
+      const isMutationAllowed = perms.allowedMutations.includes(mutationIntent);
+
+      if (isOpAllowed && isMutationAllowed) {
+        selectedActor = requestedActor;
+      } else {
+        // Valid actor but unauthorized operation or mutation
+        if (mutationIntent === "publish") {
+          selectedActor = "Orion";
+          permissionDecision = "rerouted";
+          reason = `Rerouted: Requested actor '${requestedActor}' is not authorized to publish. Redirecting to Orion.`;
+        } else {
+          selectedActor = requestedActor;
+          permissionDecision = "blocked";
+          reason = `Blocked: Requested actor '${requestedActor}' does not have permission for operation '${operationType}' or mutation '${mutationIntent}'.`;
+        }
+      }
+    } else {
+      // Infer actor from operation, risk, capability
+      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 {
+        // Fallback for general explain/plan
+        selectedActor = mutationIntent === "write" ? "Astra" : "Atlas";
+      }
+    }
+
+    // Phoenix findings check: A fix request requires findings before Phoenix acts
+    if (selectedActor === "Phoenix") {
+      const requestPath = path.join(this.cwd, ".ai-workflow/remediation-request.json");
+      let hasFindings = false;
+      if (fs.existsSync(requestPath)) {
+        try {
+          const reqData = JSON.parse(fs.readFileSync(requestPath, "utf8"));
+          if (reqData.affectedChecks && reqData.affectedChecks.length > 0) {
+            hasFindings = true;
+          }
+        } catch {
+          // ignore
+        }
+      }
+      if (!hasFindings) {
+        permissionDecision = "blocked";
+        reason = "Blocked: Phoenix acts only with concrete findings and bounded remediation.";
+      }
+    }
+
+    if (selectedActor && !workflowPath.includes(selectedActor)) {
+      workflowPath.push(selectedActor);
+    }
+
+    // Atlas self-execution guard
+    if (selectedActor === "Atlas" && (requestedActor || ["discover", "validate", "fix", "release", "deploy"].includes(operationType))) {
+      permissionDecision = "blocked";
+      reason = "Atlas self-execution guard: Atlas cannot silently execute specialized actor or capability requests.";
+    }
+
+    // Sage and Phoenix revalidation loop path in full mode:
+    if (selectedActor === "Astra" && understanding.riskLevel === "high") {
+      workflowPath.push("Sage", "Phoenix", "Sage");
+    }
+
+    return {
+      requestedActor,
+      selectedActor,
+      operationType,
+      mutationIntent,
+      permissionDecision,
+      reason,
+      workflowPath
+    };
+  }
+}

package/src/core/runtime/opencode-adapter.js

@@ -51,12 +51,33 @@ export class OpenCodeAdapter {
    */
   async execute(message, { agent = null, model = null, readOnly = false } = {}) {
     const inspection = await this.inspect();
+    const isSpecializedAgent = agent && ["Nexus", "Orion", "Astra", "Sage", "Phoenix"].includes(agent);
+
     if (!inspection.available) {
       return {
         success: false,
+        status: isSpecializedAgent ? "BLOCKED" : "FAILED",
         commandsRun: [],
         eventCount: 0,
-        error: "OpenCode CLI is not installed or not available in the system PATH."
+        error: "OpenCode CLI is not installed or not available in the system PATH.",
+        runtimeAgentRequested: agent || null,
+        runtimeAgentApplied: null,
+        runtimeAgentSupported: false,
+        runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
+      };
+    }
+
+    if (isSpecializedAgent && !inspection.supports.agent) {
+      return {
+        success: false,
+        status: "BLOCKED",
+        error: `Requested runtime actor '${agent}' cannot be applied because this OpenCode runtime does not support --agent.`,
+        runtimeAgentRequested: agent,
+        runtimeAgentApplied: null,
+        runtimeAgentSupported: false,
+        runtimeAgentSelectionMode: "unsupported",
+        commandsRun: [],
+        eventCount: 0
       };
     }
 
@@ -66,7 +87,7 @@ export class OpenCodeAdapter {
         if (inspection.supports.formatJson) {
           args.push("--format", "json");
         }
-        if (agent && inspection.supports.agent) {
+        if (isSpecializedAgent && inspection.supports.agent) {
           args.push("--agent", agent);
         }
         if (model && inspection.supports.model) {
@@ -125,7 +146,11 @@ export class OpenCodeAdapter {
                       success: false,
                       commandsRun,
                       eventCount,
-                      error: `Read-only confinement violation: tool '${name}' or command attempted write/modify operation during read-only task.`
+                      error: `Read-only confinement violation: tool '${name}' or command attempted write/modify operation during read-only task.`,
+                      runtimeAgentRequested: agent || null,
+                      runtimeAgentApplied: null,
+                      runtimeAgentSupported: inspection.supports.agent,
+                      runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
                     });
                     return;
                   }
@@ -143,7 +168,11 @@ export class OpenCodeAdapter {
           resolve({
             success: code === 0,
             commandsRun,
-            eventCount
+            eventCount,
+            runtimeAgentRequested: agent || null,
+            runtimeAgentApplied: isSpecializedAgent ? agent : null,
+            runtimeAgentSupported: inspection.supports.agent,
+            runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
           });
         });
 
@@ -153,7 +182,11 @@ export class OpenCodeAdapter {
             success: false,
             commandsRun,
             eventCount: 0,
-            error: err.message
+            error: err.message,
+            runtimeAgentRequested: agent || null,
+            runtimeAgentApplied: null,
+            runtimeAgentSupported: inspection.supports.agent,
+            runtimeAgentSelectionMode: isSpecializedAgent ? "explicit" : "default"
           });
         });
       });

package/docs/releases/v2.3.0-release-decision.md

@@ -1,35 +0,0 @@
-# AI Workflow Kit 2.3.0 Release Decision
-
-**Status:** Finalized  
-**npm publish:** Pending (Awaiting user authorization)  
-**Published dist-tag:** `latest`  
-
-## Identity
-
-- **Package:** `@williambeto/ai-workflow`
-- **Version:** `2.3.0`
-- **Commit:** `c16d06889ed4957840b69d61df43063908c3b220`
-- **Tarball SHA256:** `24b1cb412bb4503add8d8962568cdc5ea819e207e6dd0d0e3d0f9d8502c063ce`
-- **Previous public line:** `2.2.7`
-
-## Validation evidence
-
-- **Unit tests:** PASS — 142 tests passed
-- **E2E tests:** PASS — 18 tests passed (including the new read-only safety validation and Sage/Phoenix/Astra loop verification)
-- **Release-readiness validation:** PASS — 17 required files checked
-- **Full validation:** PASS — 18/18 checks completed successfully (JSON, Cross-reference, Artifact safety, External link, Documentation consistency, Workflow state, Schema, Skill, Canonical policy reference, Privacy publication gate, UI evidence gate, Delegation, Behavioral contract, Token economy, Upgrade regression, Visual regression, Release readiness, Repository structure)
-- **Safe pack:** PASS — `@williambeto/ai-workflow@2.3.0`, 310 files, zero root-level tarballs left behind
-- **Fresh consumer install:** PASS (verified via packed consumer runner in a sandbox)
-- **CLI help/init/doctor:** PASS (verified via packed consumer runner in a sandbox)
-- **Real OpenCode Smoke Test:** PASS (integrated directly into the release verification)
-- **Open Blocker/High findings:** None
-
-## Accepted limitations
-
-- See [known-limitations.md](../internal/known-limitations.md).
-
-## Decision
-
-Decision finalized for version `2.3.0`. The release includes the isolated read-only workspace runner, corrected snapshot comparisons, bypassed physical files write during read-only executions, real OpenCode smoke test integration in release verification, and Sage validation agent coordination in full mode.
-
-**Approved by:** José Willams (Human User)