ai-engineering-loop 1.0.4 → 1.0.5

package/docs/grok-cli-feasibility.md

@@ -0,0 +1,99 @@
+# Grok CLI Feasibility & Execution Strategy
+
+## 1. Executive Summary
+
+Grok CLI (verified `grok 1.0.5`) is a **first-class host** for the AI Engineering Loop. Unlike Antigravity standalone mode, Grok exposes `spawn_subagent` as a real independent child session: own context window, no parent transcript unless `resume_from` is set, and a captured `subagent_id` plus model response.
+
+When those evidence fields are present, the capability registry **must** select `TRUE_INDEPENDENT_AGENT` (skill alias: `NATIVE_SUBAGENT`).
+
+```text
+Parent (Maker + orchestrator)
+  ├─ spawn_subagent type=devil-advocate  → Finding Ledger
+  └─ spawn_subagent type=judge           → PASS | ITERATE | ESCALATE
+```
+
+Children cannot spawn children (depth 1). The parent therefore remains the orchestrator.
+
+---
+
+## 2. Empirical Discovery Record
+
+| Surface | Tested command / API | Classification | Result |
+|---|---|---|---|
+| Grok CLI binary | `~/.grok/bin/grok` (`grok 1.0.5`) | `CONFIGURATION_SUPPORTED` | Installed and authenticated in TUI sessions |
+| Native child session | `spawn_subagent` | `INVOCATION_AVAILABLE` | Enabled by default; disabled only when `GROK_SUBAGENTS=0` or `--disallowed-tools Agent` |
+| Child execution | child `subagent_id` + model response | `EXECUTION_PROVEN` | Proven only after the child returns; binary presence is not proof |
+| Project agents | `.grok/agents/devil-advocate.md`, `.grok/agents/judge.md` | `CONFIGURATION_SUPPORTED` | Registered as `subagent_type` values |
+| Skill + slash command | `.grok/skills/ai-engineering-loop/`, `.grok/commands/ai-engineering-loop.md` | `CONFIGURATION_SUPPORTED` | Grok discovers repo-local skills and command markdown |
+| Headless child | `grok -p "..."` | `FRESH_PROCESS_AGENT` | Valid fallback **after** stdout contains a model response |
+| Compressed reviewer | `caveman:cavecrew-reviewer` | `GROK_COMPRESSED_REVIEW_PRESET` | **Rejected** — output schema is `path:line: emoji severity`, not the Finding Ledger |
+| Browser tools | `browser_*` | `BROWSER_AUTOMATION_TOOL` | Not an LLM reviewer |
+| `resume_from` Maker | `spawn_subagent(resume_from=makerId)` | tainted history | **Rejected** — inherits Maker transcript |
+
+### What is NOT execution proof on Grok
+
+1. `~/.grok/bin/grok` existing on disk
+2. `.grok/agents/*.md` being discoverable
+3. Subagents being enabled in `config.toml`
+4. A persona named "reviewer" without a child response
+5. Cavecrew reviewer output that looks like a review
+
+---
+
+## 3. Mapping Loop Roles → Grok Types
+
+| Loop role | Grok `subagent_type` | `capability_mode` | `isolation` | `resume_from` |
+|---|---|---|---|---|
+| Orchestrator / Maker | parent session (or `general-purpose` if parent is orchestrator-only) | `all` | `none` | n/a |
+| Devil's Advocate | `devil-advocate` (fallback `general-purpose`) | `execute` | `none` | **omit** |
+| Judge | `judge` (fallback `general-purpose`) | `execute` | `none` | **omit** |
+
+`execute` allows git/read/search and forbids source edits. Do not use `read-only` if the child needs `git diff`. Do not use `worktree` isolation: DA and Judge must see the Maker working tree.
+
+`description` prefixes `[devil-advocate]` and `[judge]` so the Grok TUI labels the child correctly when falling back to `general-purpose`.
+
+---
+
+## 4. Artifact Barrier (still required)
+
+Grok children do not inherit parent chat, but they do receive compacted `AGENTS.md` / project instructions. That is acceptable (project context, not Maker thoughts).
+
+Still write artifacts to disk and pass **paths**, not Maker narration:
+
+- Goal Contract
+- git diff file
+- verification log (command, exit code, stdout, test counts)
+- `.ai-engineering-loop/`
+
+---
+
+## 5. Disable / fallback matrix
+
+| Condition | Selected mode |
+|---|---|
+| `spawn_subagent` available, child response captured, no `resume_from` | `TRUE_INDEPENDENT_AGENT` |
+| `spawn_subagent` missing, `grok -p` returns a model response | `FRESH_PROCESS_AGENT` |
+| `GROK_SUBAGENTS=0` or `--disallowed-tools Agent` | `CONTEXT_ISOLATION_ONLY` |
+| No grok, no spawn, no headless | `UNAVAILABLE` or artifact barrier if the same session can still read the diff |
+
+---
+
+## 6. Answers to the eight host questions
+
+1. **Independent sub-agents?** Yes — `spawn_subagent`, own context window.
+2. **Pass context?** Yes — prompt + on-disk artifacts. Do not pass Maker chat.
+3. **Same repository?** Yes — `isolation: none` shares the workspace.
+4. **Structured findings?** Yes — DA agent contract is Finding Ledger JSON.
+5. **Parent consume findings?** Yes — child summary returns to parent; Judge spawn gets the ledger.
+6. **Repeat the loop?** Yes — parent iterates; each DA/Judge spawn is fresh (no `resume_from`).
+7. **Persist state?** Yes — files under `.ai-engineering-loop/` and task artifact paths. Grok also keeps session logs under `~/.grok/sessions/`.
+8. **Token limits?** Pass artifact paths, not full transcripts. Do not dump Maker reasoning into the DA prompt.
+
+---
+
+## 7. Practical limits on Grok CLI
+
+- **Depth 1**: a DA child cannot spawn a Judge. Parent must spawn both.
+- **Plan mode**: a write-capable child is not gated by the parent's plan-mode lock. Keep DA/Judge on `capability_mode: execute` (no writes) so they cannot edit source while the parent is in plan mode.
+- **Headless `--disallowed-tools Agent`**: kills native review. Disclose `CONTEXT_ISOLATION_ONLY`.
+- **Cavecrew**: useful for cheap locate/review, **not** for this loop's Judge input.

package/lib/orchestration.js

@@ -11,9 +11,15 @@
  * 3. Artifact isolation is strictly reported as CONTEXT_ISOLATION_ONLY (Independent LLM execution: NOT PROVEN).
  * 4. browser_subagent is browser automation and must NOT be classified as an LLM subagent.
  * 5. agentapi send-message is an IPC communication capability and must NEVER activate agent execution.
+ * 6. grok spawn_subagent is a true independent child session (own context, no parent transcript)
+ *    when a child id and model response are captured. GROK_SUBAGENTS=0 disables invocation.
+ * 7. caveman:cavecrew-reviewer is a compressed code-review preset with a different output schema
+ *    and must NEVER be used as the Devil's Advocate or Judge.
  */
 
 const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
 // 1. Standard 5 Execution Modes
 const EXECUTION_MODES = {
@@ -49,6 +55,30 @@ const EXECUTION_MODES = {
   }
 };
 
+/**
+ * Skill / agent-spec aliases. The skill historically used NATIVE_SUBAGENT etc.
+ * Canonical runtime IDs remain the 5 EXECUTION_MODES keys.
+ */
+const EXECUTION_MODE_ALIASES = {
+  NATIVE_SUBAGENT: 'TRUE_INDEPENDENT_AGENT',
+  SDK_AGENT: 'ISOLATED_AGENT_INSTANCE',
+  HEADLESS_SUBPROCESS: 'FRESH_PROCESS_AGENT',
+  ARTIFACT_ISOLATED_REVIEW: 'CONTEXT_ISOLATION_ONLY'
+};
+
+const GROK_FORBIDDEN_REVIEW_TYPES = [
+  'caveman:cavecrew-reviewer',
+  'caveman:cavecrew-builder',
+  'caveman:cavecrew-investigator',
+  'explore',
+  'plan'
+];
+
+function resolveExecutionModeId(modeId) {
+  if (!modeId) return 'UNAVAILABLE';
+  return EXECUTION_MODE_ALIASES[modeId] || modeId;
+}
+
 /**
  * 2. Standardized Capability Evidence Factory with 3-Stage Lifecycle
  */
@@ -126,6 +156,15 @@ function isCapabilityProvenForMode(evidence, targetModeId) {
     return false;
   }
 
+  // Reject compressed review presets that do not emit the Finding Ledger schema
+  if (
+    evidence.classification === 'GROK_COMPRESSED_REVIEW_PRESET' ||
+    GROK_FORBIDDEN_REVIEW_TYPES.includes(evidence.mechanism) ||
+    GROK_FORBIDDEN_REVIEW_TYPES.includes(evidence.commandOrApi)
+  ) {
+    return false;
+  }
+
   // Reject documentation-only or configuration-only claims
   if (evidence.isDocumentationOnly || (evidence.configurationSupported && !evidence.executionProven)) {
     if (targetModeId !== 'CONTEXT_ISOLATION_ONLY') {
@@ -376,7 +415,142 @@ function computeJudgeVerdict({
 }
 
 /**
- * 9. Truthful Review Report Generator
+ * 9. Detect Grok CLI as a host runtime.
+ * Presence of the grok binary is CONFIGURATION_SUPPORTED.
+ * GROK_SUBAGENTS=0 means invocation is disabled even if grok is installed.
+ * Execution is never proven from detection alone.
+ */
+function detectGrokRuntime(env = process.env, fsApi = fs) {
+  const grokHome = env.GROK_HOME || path.join(env.HOME || env.USERPROFILE || '', '.grok');
+  const grokBinCandidates = [
+    env.GROK_BIN,
+    path.join(grokHome, 'bin', 'grok'),
+    path.join(grokHome, 'bin', 'agent')
+  ].filter(Boolean);
+
+  const grokBin = grokBinCandidates.find((candidate) => {
+    try {
+      return fsApi.existsSync(candidate);
+    } catch (e) {
+      return false;
+    }
+  }) || null;
+
+  const grokPresent = Boolean(grokBin);
+  const subagentsDisabled = env.GROK_SUBAGENTS === '0';
+  const invocationAvailable = grokPresent && !subagentsDisabled;
+
+  let reason;
+  if (!grokPresent) {
+    reason = 'Grok CLI binary not found under GROK_HOME/bin';
+  } else if (subagentsDisabled) {
+    reason = 'GROK_SUBAGENTS=0 disables spawn_subagent; fall back to CONTEXT_ISOLATION_ONLY or grok -p';
+  } else {
+    reason = 'Grok CLI present; spawn_subagent is the native independent-agent tool (enabled by default)';
+  }
+
+  return {
+    host: grokPresent ? 'grok-cli' : 'unknown',
+    grokHome,
+    grokBin,
+    configurationSupported: grokPresent,
+    invocationAvailable,
+    executionProven: false,
+    subagentsDisabled,
+    commandOrApi: 'spawn_subagent',
+    headlessCommand: 'grok -p',
+    reason
+  };
+}
+
+/**
+ * 10. Build capability evidence for Grok spawn_subagent.
+ * Independent context is proven only when the child did not resume a Maker transcript.
+ */
+function createGrokCapabilityEvidence({
+  invocationAvailable = false,
+  executionProven = false,
+  childConversationId = null,
+  childModelResponse = null,
+  executionIdentity = null,
+  independentContextProven = false,
+  historyInherited = null,
+  resumeFrom = null,
+  reason = null
+} = {}) {
+  const resumedMaker = Boolean(resumeFrom);
+  const inherited = historyInherited === true || resumedMaker;
+  const modelExecuted = Boolean(executionProven || childModelResponse);
+  const fullyProven = Boolean(
+    modelExecuted &&
+      childConversationId &&
+      executionIdentity &&
+      independentContextProven &&
+      !inherited
+  );
+
+  return createCapabilityEvidence({
+    mechanism: 'grok-spawn_subagent',
+    classification: fullyProven
+      ? 'TRUE_INDEPENDENT_AGENT'
+      : invocationAvailable
+        ? 'INVOCATION_AVAILABLE'
+        : 'CONFIGURATION_SUPPORTED_WITHOUT_INVOCATION_TOOL',
+    configurationSupported: true,
+    invocationAvailable: Boolean(invocationAvailable),
+    executionProven: fullyProven,
+    available: Boolean(invocationAvailable || fullyProven),
+    commandOrApi: 'spawn_subagent',
+    childConversationId,
+    childModelResponse,
+    executionIdentity,
+    modelExecutionProven: modelExecuted,
+    independentContextProven: Boolean(independentContextProven && !inherited),
+    historyInherited: inherited ? true : historyInherited,
+    reason: reason || (resumedMaker
+      ? 'resume_from inherits the source transcript; Devil\'s Advocate and Judge must spawn fresh'
+      : null)
+  });
+}
+
+/**
+ * 11. Grok spawn plan for Devil's Advocate / Judge.
+ * Parent orchestrator spawns children; children must not spawn children (depth 1).
+ * Never pass resume_from. Never use cavecrew-reviewer (wrong output schema).
+ */
+function buildGrokReviewSpawnPlan({
+  role,
+  iteration = 1,
+  artifactPaths = {}
+} = {}) {
+  if (role !== 'devil-advocate' && role !== 'judge') {
+    throw new Error('Grok review spawn role must be devil-advocate or judge');
+  }
+
+  return {
+    tool: 'spawn_subagent',
+    subagent_type: role,
+    fallback_subagent_type: 'general-purpose',
+    description: role === 'judge'
+      ? `[judge] evaluate iteration ${iteration}`
+      : `[devil-advocate] review iteration ${iteration}`,
+    background: false,
+    capability_mode: 'execute',
+    isolation: 'none',
+    resume_from: null,
+    forbidden_types: [...GROK_FORBIDDEN_REVIEW_TYPES],
+    artifactPaths: {
+      goalContract: artifactPaths.goalContract || null,
+      gitDiff: artifactPaths.gitDiff || null,
+      verificationLogs: artifactPaths.verificationLogs || null,
+      projectContext: artifactPaths.projectContext || '.ai-engineering-loop/',
+      findingLedger: artifactPaths.findingLedger || null
+    }
+  };
+}
+
+/**
+ * 12. Truthful Review Report Generator
  * Enforces mandatory reporting headers and strictly prevents misleading phrasing.
  */
 function formatExecutionReport({ selectedMode, capabilityRegistry = {} }) {
@@ -398,6 +572,9 @@ function formatExecutionReport({ selectedMode, capabilityRegistry = {} }) {
 
 module.exports = {
   EXECUTION_MODES,
+  EXECUTION_MODE_ALIASES,
+  GROK_FORBIDDEN_REVIEW_TYPES,
+  resolveExecutionModeId,
   createCapabilityEvidence,
   isCapabilityProvenForMode,
   selectExecutionMode,
@@ -405,5 +582,8 @@ module.exports = {
   validateVerificationEvidence,
   validateFindingLedger,
   computeJudgeVerdict,
-  formatExecutionReport
+  formatExecutionReport,
+  detectGrokRuntime,
+  createGrokCapabilityEvidence,
+  buildGrokReviewSpawnPlan
 };

package/package.json

@@ -1,11 +1,29 @@
 {
   "name": "ai-engineering-loop",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A reusable, framework-agnostic AI Engineering Operating System for autonomous coding agents.",
   "main": "bin/ai-engineering-loop.js",
   "bin": {
     "ai-engineering-loop": "bin/ai-engineering-loop.js"
   },
+  "files": [
+    "bin/",
+    "lib/",
+    "core/",
+    "agents/",
+    "policies/",
+    "profiles/",
+    "adapters/",
+    "templates/",
+    "examples/",
+    "docs/",
+    "tests/",
+    "scripts/",
+    ".grok/",
+    "LICENSE",
+    "README.md",
+    "README.npm.md"
+  ],
   "scripts": {
     "init": "node bin/ai-engineering-loop.js",
     "test": "node --test tests/*.test.js"
@@ -21,7 +39,9 @@
     "devils-advocate",
     "verification",
     "autonomous-agents",
-    "antigravity"
+    "antigravity",
+    "grok",
+    "subagents"
   ],
   "author": "Ega Gofur",
   "license": "MIT",

package/tests/grok-runtime.test.js

@@ -0,0 +1,201 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const {
+  EXECUTION_MODES,
+  EXECUTION_MODE_ALIASES,
+  GROK_FORBIDDEN_REVIEW_TYPES,
+  resolveExecutionModeId,
+  createCapabilityEvidence,
+  selectExecutionMode,
+  detectGrokRuntime,
+  createGrokCapabilityEvidence,
+  buildGrokReviewSpawnPlan,
+  formatExecutionReport
+} = require('../lib/orchestration.js');
+
+function fakeFs(existingPaths) {
+  return {
+    existsSync: (p) => existingPaths.includes(p)
+  };
+}
+
+test('Grok spawn_subagent with full execution proof selects TRUE_INDEPENDENT_AGENT', () => {
+  const nativeSubagent = createGrokCapabilityEvidence({
+    invocationAvailable: true,
+    childConversationId: 'grok-child-da-01',
+    childModelResponse: 'Finding ledger JSON emitted',
+    executionIdentity: 'spawn_subagent:grok-child-da-01',
+    independentContextProven: true,
+    historyInherited: false
+  });
+
+  const selected = selectExecutionMode({
+    nativeSubagent,
+    artifactIsolation: createCapabilityEvidence({
+      mechanism: 'clean-slate-artifact-barrier',
+      classification: 'CONTEXT_ISOLATION_ONLY',
+      available: true
+    })
+  });
+
+  assert.strictEqual(selected.id, EXECUTION_MODES.TRUE_INDEPENDENT_AGENT.id);
+  assert.strictEqual(selected.isIndependentExecutionProven, true);
+  assert.strictEqual(nativeSubagent.commandOrApi, 'spawn_subagent');
+});
+
+test('GROK_SUBAGENTS=0 disables invocation even when grok binary exists', () => {
+  const grokBin = '/tmp/fake-grok-home/bin/grok';
+  const runtime = detectGrokRuntime(
+    { GROK_HOME: '/tmp/fake-grok-home', GROK_SUBAGENTS: '0', HOME: '/tmp' },
+    fakeFs([grokBin])
+  );
+
+  assert.strictEqual(runtime.host, 'grok-cli');
+  assert.strictEqual(runtime.configurationSupported, true);
+  assert.strictEqual(runtime.invocationAvailable, false);
+  assert.strictEqual(runtime.executionProven, false);
+  assert.match(runtime.reason, /GROK_SUBAGENTS=0/);
+
+  const selected = selectExecutionMode({
+    nativeSubagent: createGrokCapabilityEvidence({
+      invocationAvailable: runtime.invocationAvailable,
+      reason: runtime.reason
+    }),
+    artifactIsolation: createCapabilityEvidence({
+      mechanism: 'clean-slate-artifact-barrier',
+      classification: 'CONTEXT_ISOLATION_ONLY',
+      available: true
+    })
+  });
+
+  assert.strictEqual(selected.id, EXECUTION_MODES.CONTEXT_ISOLATION_ONLY.id);
+});
+
+test('Grok binary present with default subagents maps to INVOCATION_AVAILABLE, not execution proven', () => {
+  const grokBin = '/tmp/fake-grok-home/bin/grok';
+  const runtime = detectGrokRuntime(
+    { GROK_HOME: '/tmp/fake-grok-home', HOME: '/tmp' },
+    fakeFs([grokBin])
+  );
+
+  assert.strictEqual(runtime.invocationAvailable, true);
+  assert.strictEqual(runtime.executionProven, false);
+
+  const evidence = createGrokCapabilityEvidence({
+    invocationAvailable: true
+  });
+
+  const selected = selectExecutionMode({
+    nativeSubagent: evidence,
+    artifactIsolation: createCapabilityEvidence({
+      mechanism: 'clean-slate-artifact-barrier',
+      classification: 'CONTEXT_ISOLATION_ONLY',
+      available: true
+    })
+  });
+
+  assert.strictEqual(evidence.classification, 'INVOCATION_AVAILABLE');
+  assert.strictEqual(selected.id, EXECUTION_MODES.CONTEXT_ISOLATION_ONLY.id);
+});
+
+test('resume_from Maker transcript cannot activate TRUE_INDEPENDENT_AGENT', () => {
+  const tainted = createGrokCapabilityEvidence({
+    invocationAvailable: true,
+    childConversationId: 'grok-child-resume',
+    childModelResponse: 'I remember the Maker rationale',
+    executionIdentity: 'spawn_subagent:resume',
+    independentContextProven: true,
+    resumeFrom: 'maker-subagent-id'
+  });
+
+  const selected = selectExecutionMode({
+    nativeSubagent: tainted,
+    artifactIsolation: createCapabilityEvidence({
+      mechanism: 'clean-slate-artifact-barrier',
+      classification: 'CONTEXT_ISOLATION_ONLY',
+      available: true
+    })
+  });
+
+  assert.strictEqual(tainted.historyInherited, true);
+  assert.strictEqual(selected.id, EXECUTION_MODES.CONTEXT_ISOLATION_ONLY.id);
+});
+
+test('caveman:cavecrew-reviewer cannot serve as Devil\'s Advocate', () => {
+  const compressed = createCapabilityEvidence({
+    mechanism: 'caveman:cavecrew-reviewer',
+    classification: 'GROK_COMPRESSED_REVIEW_PRESET',
+    available: true,
+    invocationAvailable: true,
+    executionProven: true,
+    childConversationId: 'cave-1',
+    executionIdentity: 'cave-1',
+    childModelResponse: 'path:line: 🔴 BLOCKER: bug. fix it.',
+    modelExecutionProven: true,
+    independentContextProven: true
+  });
+
+  const selected = selectExecutionMode({
+    nativeSubagent: compressed,
+    artifactIsolation: createCapabilityEvidence({
+      mechanism: 'clean-slate-artifact-barrier',
+      classification: 'CONTEXT_ISOLATION_ONLY',
+      available: true
+    })
+  });
+
+  assert.strictEqual(selected.id, EXECUTION_MODES.CONTEXT_ISOLATION_ONLY.id);
+  assert.ok(GROK_FORBIDDEN_REVIEW_TYPES.includes('caveman:cavecrew-reviewer'));
+});
+
+test('Skill aliases resolve to canonical execution mode ids', () => {
+  assert.strictEqual(resolveExecutionModeId('NATIVE_SUBAGENT'), 'TRUE_INDEPENDENT_AGENT');
+  assert.strictEqual(resolveExecutionModeId('SDK_AGENT'), 'ISOLATED_AGENT_INSTANCE');
+  assert.strictEqual(resolveExecutionModeId('HEADLESS_SUBPROCESS'), 'FRESH_PROCESS_AGENT');
+  assert.strictEqual(resolveExecutionModeId('ARTIFACT_ISOLATED_REVIEW'), 'CONTEXT_ISOLATION_ONLY');
+  assert.strictEqual(EXECUTION_MODE_ALIASES.NATIVE_SUBAGENT, EXECUTION_MODES.TRUE_INDEPENDENT_AGENT.id);
+});
+
+test('Grok DA/Judge spawn plan is fresh, execute-only, and forbids compressed review types', () => {
+  const da = buildGrokReviewSpawnPlan({
+    role: 'devil-advocate',
+    iteration: 2,
+    artifactPaths: { goalContract: 'goal.md', gitDiff: 'diff.patch' }
+  });
+
+  assert.strictEqual(da.tool, 'spawn_subagent');
+  assert.strictEqual(da.subagent_type, 'devil-advocate');
+  assert.strictEqual(da.fallback_subagent_type, 'general-purpose');
+  assert.strictEqual(da.description, '[devil-advocate] review iteration 2');
+  assert.strictEqual(da.background, false);
+  assert.strictEqual(da.capability_mode, 'execute');
+  assert.strictEqual(da.isolation, 'none');
+  assert.strictEqual(da.resume_from, null);
+  assert.ok(da.forbidden_types.includes('caveman:cavecrew-reviewer'));
+  assert.strictEqual(da.artifactPaths.goalContract, 'goal.md');
+
+  const judge = buildGrokReviewSpawnPlan({ role: 'judge', iteration: 2 });
+  assert.strictEqual(judge.subagent_type, 'judge');
+  assert.strictEqual(judge.description, '[judge] evaluate iteration 2');
+  assert.strictEqual(judge.resume_from, null);
+});
+
+test('buildGrokReviewSpawnPlan rejects unknown roles', () => {
+  assert.throws(
+    () => buildGrokReviewSpawnPlan({ role: 'caveman:cavecrew-reviewer' }),
+    /must be devil-advocate or judge/
+  );
+});
+
+test('Grok proven spawn report discloses independent execution', () => {
+  const report = formatExecutionReport({
+    selectedMode: EXECUTION_MODES.TRUE_INDEPENDENT_AGENT,
+    capabilityRegistry: {
+      nativeSubagent: { invocationAvailable: true }
+    }
+  });
+
+  assert.match(report, /Execution Mode: TRUE_INDEPENDENT_AGENT/);
+  assert.match(report, /Independent LLM Execution: PROVEN/);
+  assert.match(report, /Native Subagent Invocation: AVAILABLE/);
+});