@williambeto/ai-workflow 2.2.6 → 2.3.0

package/src/commands/init.js

@@ -6,7 +6,7 @@ import { exists, writeFileSafe, readJson } from "../core/filesystem.js";
 import { createManagedBackup, createManagedPathBackup } from "../core/backup.js";
 import { mergeOpencodeConfig } from "../core/opencode-merge.js";
 import { buildSymlinkEntries, isSymlinkTo, setupInternalSymlinks } from "../core/symlink-layout.js";
-import { GeminiAdapter, ClaudeAdapter, CodexAdapter } from "../adapters/index.js";
+import { GeminiAdapter, ClaudeAdapter, CodexAdapter, AntigravityAdapter } from "../adapters/index.js";
 
 function summarize(actions) {
   const createCount = actions.filter((a) => a.type === "create").length;
@@ -100,7 +100,7 @@ async function injectScripts(cwd) {
 }
 
 export async function runInit({
- cwd, yes, force, dryRun, noInstall, noOverwrite, gemini, claude, codex, "dev-mode": devMode, profile }) {
+ cwd, yes, force, dryRun, noInstall, noOverwrite, gemini, claude, codex, antigravity, "dev-mode": devMode, profile }) {
   // Self-execution guard
   if (!devMode) {
     try {
@@ -131,6 +131,7 @@ export async function runInit({
   if (gemini) platforms.push("gemini");
   if (claude) platforms.push("claude");
   if (codex) platforms.push("codex");
+  if (antigravity) platforms.push("antigravity");
 
   console.log(`ai-workflow: initializing in ${cwd}`);
   console.log(`Profile: ${selectedProfile}`);
@@ -260,6 +261,9 @@ export async function runInit({
   if (claude) {
     generatedIgnoreEntries.push(".claude/");
   }
+  if (antigravity) {
+    generatedIgnoreEntries.push(".agents/");
+  }
 
   const gitignoreResult = await upsertGitignoreBlock(cwd, generatedIgnoreEntries);
   const scriptInjected = await injectScripts(cwd);
@@ -303,6 +307,25 @@ export async function runInit({
       await adapter.deploy(installRoot);
       console.log("- codex: deployed AI Workflow Kit agents to .agents/, .codex/, and .github/ (native discovery enabled)");
     }
+
+    if (antigravity) {
+      const adapter = new AntigravityAdapter({ cwd });
+      
+      // Collect specialized skills from the new opencode/skills path
+      const skillFolders = await fs.readdir(skillsDir).catch(() => []);
+      const skillFiles = [];
+      for (const folder of skillFolders) {
+        const skillPath = path.join(skillsDir, folder, "SKILL.md");
+        if (await exists(skillPath)) {
+          skillFiles.push(skillPath);
+        }
+      }
+
+      const allFiles = [...agentFiles, ...skillFiles];
+      const transformed = await Promise.all(allFiles.map((f) => adapter.transform(f)));
+      await adapter.deploy(transformed, installRoot);
+      console.log(`- antigravity: deployed AI Workflow Kit agents to .agents/ (native discovery enabled)`);
+    }
   }
 
   console.log("Installation complete.");

package/src/core/delegation-controller.js

@@ -0,0 +1,134 @@
+import { OpenCodeAdapter } from "./runtime/opencode-adapter.js";
+
+/**
+ * DelegationController - Manages and logs coordination between Atlas, Astra, Sage, and Phoenix.
+ */
+export class DelegationController {
+  constructor({ cwd = process.cwd(), ledger, adapter } = {}) {
+    this.cwd = cwd;
+    this.ledger = ledger;
+    this.adapter = adapter || new OpenCodeAdapter({ cwd });
+  }
+
+  /**
+   * Logs routing decision by Atlas.
+   */
+  async route(naturalRequest, classification) {
+    if (this.ledger) {
+      this.ledger.logEvent({
+        actor: "Atlas",
+        actorType: "control-plane",
+        observed: true,
+        eventType: "routing",
+        provenance: "request-classifier",
+        data: {
+          request: naturalRequest,
+          classification,
+          event: "routing.completed"
+        }
+      });
+    }
+  }
+
+  /**
+   * Logs and executes the implementation process by Astra.
+   */
+  async implement(promptMsg, owner, options = {}) {
+    if (this.ledger) {
+      this.ledger.logEvent({
+        actor: owner,
+        actorType: "runtime-agent",
+        observed: true,
+        runtime: "opencode",
+        eventType: "implementation_start",
+        provenance: "opencode-adapter",
+        data: {
+          agent: owner,
+          prompt: promptMsg,
+          event: "implementation.started"
+        }
+      });
+    }
+
+    const runResult = await this.adapter.execute(promptMsg, { agent: owner, ...options });
+
+    if (this.ledger) {
+      this.ledger.logEvent({
+        actor: owner,
+        actorType: "runtime-agent",
+        observed: true,
+        runtime: "opencode",
+        eventType: "implementation_complete",
+        provenance: "opencode-adapter",
+        data: {
+          success: runResult.success,
+          commandsRun: runResult.commandsRun || [],
+          eventCount: runResult.eventCount || 0,
+          error: runResult.error,
+          event: "implementation.completed"
+        }
+      });
+    }
+
+    return runResult;
+  }
+
+  /**
+   * Runs validation locally without logging Sage since no validation agent runtime was executed.
+   */
+  async validate(taskSlug, mode, profile, verifyFn) {
+    const result = await verifyFn();
+
+    if (mode === "full") {
+      if (this.ledger) {
+        this.ledger.logEvent({
+          actor: "Sage",
+          actorType: "auditor",
+          observed: true,
+          runtime: "opencode",
+          eventType: "validation_start",
+          provenance: "opencode-adapter",
+          data: {
+            agent: "Sage",
+            event: "validation.started"
+          }
+        });
+      }
+
+      let gitDiff = "";
+      try {
+        const { execSync } = await import("node:child_process");
+        gitDiff = execSync("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      } catch {
+        // ignore
+      }
+
+      const prompt = `Please validate the implementation. Diff:\n${gitDiff}\nLocal Evidence:\n${JSON.stringify(result, null, 2)}`;
+      const runResult = await this.adapter.execute(prompt, { agent: "Sage" });
+
+      if (this.ledger) {
+        this.ledger.logEvent({
+          actor: "Sage",
+          actorType: "auditor",
+          observed: true,
+          runtime: "opencode",
+          eventType: "validation_complete",
+          provenance: "opencode-adapter",
+          data: {
+            success: runResult.success,
+            commandsRun: runResult.commandsRun || [],
+            eventCount: runResult.eventCount || 0,
+            error: runResult.error,
+            event: "validation.completed"
+          }
+        });
+      }
+
+      if (!runResult.success) {
+        result.overallStatus = "FAIL_QUALITY_GATE";
+      }
+    }
+
+    return result;
+  }
+}

package/src/core/evidence/evidence-ledger.js

@@ -0,0 +1,53 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * EvidenceLedger - Traces structural workflow events to make delegation observable.
+ */
+export class EvidenceLedger {
+  constructor({ cwd = process.cwd(), workflowId = "unknown" } = {}) {
+    this.cwd = cwd;
+    this.workflowId = workflowId;
+    this.events = [];
+  }
+
+  /**
+   * Logs a workflow event to the ledger.
+   * @param {Object} eventParam
+   * @param {string} eventParam.actor - The agent name (Atlas, Astra, Sage, Phoenix).
+   * @param {string} eventParam.eventType - Type of event.
+   * @param {string} eventParam.provenance - Originating component.
+   * @param {Object} [eventParam.data] - Additional metadata.
+   * @returns {Object} The logged event.
+   */
+  logEvent({ actor, eventType, provenance, data = {}, actorType, observed, runtime }) {
+    const event = {
+      workflowId: this.workflowId,
+      timestamp: new Date().toISOString(),
+      actor,
+      actorType: actorType !== undefined ? actorType : undefined,
+      observed: observed !== undefined ? observed : undefined,
+      runtime: runtime !== undefined ? runtime : undefined,
+      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.
+   * @param {string} filePath - Absolute or relative path.
+   */
+  async save(filePath) {
+    const targetPath = path.isAbsolute(filePath) ? filePath : path.join(this.cwd, filePath);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, JSON.stringify(this.events, null, 2), "utf8");
+  }
+}

package/src/core/execution-planner.js

@@ -21,6 +21,10 @@ export class ExecutionPlanner {
       ? path.join("docs/workflows", taskSlug, "spec.md")
       : null;
 
+    const owner = classification.intent === "write"
+      ? "Astra"
+      : classification.owner;
+
     // Build default expected validations based on the resolved profile
     const validationsExpected = [];
     if (classification.validationNeeded) {
@@ -45,7 +49,7 @@ export class ExecutionPlanner {
       objective: classification.request,
       scope: classification.intent === "read-only" ? "Analysis and verification" : "Implementation of requested behavior",
       restrictions,
-      owner: classification.owner,
+      owner,
       skills: [...classification.skills],
       branchNeeded,
       branchName: branchNeeded ? `feat/${taskSlug}` : null,

package/src/core/finalization/finalizer.js

@@ -0,0 +1,77 @@
+import { WorkspaceSnapshot } from "./workspace-snapshot.js";
+
+export class Finalizer {
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+    this.snapshotManager = new WorkspaceSnapshot({ cwd });
+  }
+
+  /**
+   * Compares the current workspace state with a previously captured snapshot.
+   * @param {Object} previousSnapshot - The snapshot object captured earlier.
+   * @returns {Object} { valid: boolean, changes: { added: string[], modified: string[], deleted: string[] } }
+   */
+  async verifyIntegrity(previousSnapshot) {
+    const currentSnapshot = await this.snapshotManager.capture();
+    const added = [];
+    const modified = [];
+    const deleted = [];
+
+    let valid = true;
+
+    // Compare metadata and git trees
+    if (previousSnapshot.branch !== currentSnapshot.branch) {
+      modified.push(`branch:${previousSnapshot.branch}->${currentSnapshot.branch}`);
+      valid = false;
+    }
+    if (previousSnapshot.head !== currentSnapshot.head) {
+      modified.push(`head:${previousSnapshot.head}->${currentSnapshot.head}`);
+      valid = false;
+    }
+    if (previousSnapshot.indexTree !== currentSnapshot.indexTree) {
+      modified.push(`indexTree:${previousSnapshot.indexTree}->${currentSnapshot.indexTree}`);
+      valid = false;
+    }
+    if (previousSnapshot.stagedDiffHash !== currentSnapshot.stagedDiffHash) {
+      modified.push("stagedDiff");
+      valid = false;
+    }
+    if (previousSnapshot.unstagedDiffHash !== currentSnapshot.unstagedDiffHash) {
+      modified.push("unstagedDiff");
+      valid = false;
+    }
+    if (previousSnapshot.untrackedFilesHash !== currentSnapshot.untrackedFilesHash) {
+      modified.push("untrackedFiles");
+      valid = false;
+    }
+
+    // Check for additions and modifications in files
+    const prevFiles = previousSnapshot.files || {};
+    const currFiles = currentSnapshot.files || {};
+
+    for (const [file, info] of Object.entries(currFiles)) {
+      const prevInfo = prevFiles[file];
+      if (!prevInfo) {
+        added.push(file);
+      } else if (prevInfo.sha256 !== info.sha256 || prevInfo.mode !== info.mode) {
+        modified.push(file);
+      }
+    }
+
+    // Check for deletions in files
+    for (const file of Object.keys(prevFiles)) {
+      if (!currFiles[file]) {
+        deleted.push(file);
+      }
+    }
+
+    if (added.length > 0 || modified.length > 0 || deleted.length > 0) {
+      valid = false;
+    }
+
+    return {
+      valid,
+      changes: { added, modified, deleted }
+    };
+  }
+}

package/src/core/finalization/workspace-snapshot.js

@@ -0,0 +1,110 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+
+export class WorkspaceSnapshot {
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+
+  isIgnored(relativePath) {
+    const norm = relativePath.replaceAll("\\", "/");
+    if (norm === "node_modules" || norm.startsWith("node_modules/")) return true;
+    if (norm === "vendor" || norm.startsWith("vendor/")) return true;
+    if (norm === ".git" || norm.startsWith(".git/")) return true;
+    if (norm === "EVIDENCE.json") return true;
+    if (norm === ".ai-workflow/EVIDENCE.json") return true;
+    if (norm.startsWith(".ai-workflow/history/")) return true;
+    if (norm.startsWith(".ai-workflow/handoffs/")) return true;
+    return false;
+  }
+
+  async capture() {
+    const files = {};
+    await this.scanDir(this.cwd, files);
+
+    const execGit = (args) => {
+      try {
+        return execSync(`git ${args}`, { cwd: this.cwd, encoding: "utf8", stdio: "pipe" }).trim();
+      } catch {
+        return "";
+      }
+    };
+
+    const branch = execGit("rev-parse --abbrev-ref HEAD");
+    const head = execGit("rev-parse HEAD");
+    const indexTree = execGit("write-tree");
+
+    const stagedDiff = execGit("diff --cached");
+    const unstagedDiff = execGit("diff");
+    const untrackedFiles = execGit("status --porcelain");
+
+    const hashString = (str) => {
+      return crypto.createHash("sha256").update(str).digest("hex");
+    };
+
+    return {
+      branch,
+      head,
+      indexTree,
+      files,
+      stagedDiffHash: hashString(stagedDiff),
+      unstagedDiffHash: hashString(unstagedDiff),
+      untrackedFilesHash: hashString(untrackedFiles)
+    };
+  }
+
+  async scanDir(dir, filesMap) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(this.cwd, fullPath);
+
+        if (this.isIgnored(relativePath)) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          await this.scanDir(fullPath, filesMap);
+        } else if (entry.isFile()) {
+          try {
+            const stat = await fs.stat(fullPath);
+            const content = await fs.readFile(fullPath);
+            const sha256 = crypto.createHash("sha256").update(content).digest("hex");
+            const isExecutable = (stat.mode & 0o111) !== 0;
+            const mode = isExecutable ? "100755" : "100644";
+
+            filesMap[relativePath] = {
+              sha256,
+              mode
+            };
+          } catch {
+            // ignore unreadable/locked files
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  calculateHash(snapshot) {
+    const hash = crypto.createHash("sha256");
+    hash.update(snapshot.branch || "");
+    hash.update(snapshot.head || "");
+    hash.update(snapshot.indexTree || "");
+    hash.update(snapshot.stagedDiffHash || "");
+    hash.update(snapshot.unstagedDiffHash || "");
+    hash.update(snapshot.untrackedFilesHash || "");
+
+    const sortedFiles = Object.keys(snapshot.files || {}).sort();
+    for (const file of sortedFiles) {
+      hash.update(file);
+      hash.update(snapshot.files[file].sha256);
+      hash.update(snapshot.files[file].mode);
+    }
+    return hash.digest("hex");
+  }
+}

package/src/core/gates/branch-gate.js

@@ -76,66 +76,54 @@ export class BranchGate {
   }
 
   /**
-   * @param {string} override
-   * @param {{autoRecover?: boolean, taskSlug?: string, readOnly?: boolean}} options
+   * Strictly verifies branch safety without any override bypasses.
    */
-  check(override = "", { autoRecover = false, taskSlug = "implementation", readOnly = false } = {}) {
+  check(overrideIgnored = "", { taskSlug = "implementation", readOnly = false } = {}) {
     if (readOnly) {
       const currentBranch = this.getCurrentBranch();
       return { blocked: false, branch: currentBranch, recovered: false, readOnly: true };
     }
 
     try {
-      // Enforce fail-closed: verify inside worktree first
+      // 1. Verify inside worktree (Git availability)
       try {
         this.run("git rev-parse --is-inside-work-tree");
       } catch (e) {
-        const reason = "Not inside a Git repository or Git is unavailable. Implementation work is blocked.";
+        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 };
       }
 
+      // 2. Get current branch
       const currentBranch = this.getCurrentBranch();
-      if (currentBranch === "unknown") {
+      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 };
       }
-      const isProtected = this.protectedBranches.includes(currentBranch);
-      if (!isProtected) return { blocked: false, branch: currentBranch, recovered: false };
 
-      if (override && override.trim().length >= 20) {
-        this.log(`AUTHORIZED BYPASS on '${currentBranch}': ${override.trim()}`);
-        return { blocked: false, branch: currentBranch, authorized: true, recovered: false };
+      const isProtected = this.protectedBranches.includes(currentBranch);
+      if (!isProtected) {
+        return { blocked: false, branch: currentBranch, recovered: false };
       }
 
-      if (autoRecover) {
-        const dirty = this.getDirtyState();
-        if (dirty.tracked.length > 0) {
-          const reason = `Unsafe tracked changes prevent Branch Gate Auto-Recovery: ${dirty.tracked.join(", ")}`;
-          this.log(`BLOCKED AUTO-RECOVERY on '${currentBranch}': ${reason}`);
-          return { blocked: true, branch: currentBranch, reason, dirtyState: dirty };
-        }
-
-        const recoveredBranch = this.createScopedBranch(taskSlug);
-        this.log(`AUTO-RECOVERED '${currentBranch}' -> '${recoveredBranch}'`);
-        return {
-          blocked: false,
-          branch: recoveredBranch,
-          branchBefore: currentBranch,
-          recovered: true,
-          dirtyState: dirty
-        };
+      // 3. Protected branch checks - any dirty file blocks
+      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 };
       }
 
-      const reason = override && override.trim().length < 20
-        ? "Override justification too short (min 20 chars)."
-        : `Direct commits to '${currentBranch}' are prohibited.`;
-      this.log(`BLOCKED ATTEMPT on '${currentBranch}': ${reason}`);
+      // 4. Create scoped branch (Auto-recover)
+      const recoveredBranch = this.createScopedBranch(taskSlug);
+      this.log(`AUTO-RECOVERED '${currentBranch}' -> '${recoveredBranch}'`);
       return {
-        blocked: true,
-        branch: currentBranch,
-        reason: `${reason} Enable safe auto-recovery or use AI_OVERRIDE with a concrete justification.`
+        blocked: false,
+        branch: recoveredBranch,
+        branchBefore: currentBranch,
+        recovered: true,
+        dirtyState: dirty
       };
     } catch (error) {
       const reason = `Git command failure on branch gate check: ${error.message}`;

package/src/core/gates/merge-gate.js

@@ -0,0 +1,74 @@
+import { execSync } from "node:child_process";
+
+/**
+ * MergeGate verifies that commit history on integration branches respects
+ * the non-fast-forward (--no-ff) merge strategy, preserving feature branch
+ * topology instead of flattening/fast-forwarding.
+ */
+export class MergeGate {
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+
+  runGit(command) {
+    return execSync(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+
+  /**
+   * Checks the commit history of the repository/branch.
+   * @param {string} branchName The branch to check.
+   * @returns {{ status: "PASS" | "FAIL_QUALITY_GATE" | "ERROR", reason?: string }}
+   */
+  check(branchName) {
+    try {
+      // Get the last 50 commits with parent hashes and subjects
+      const logOutput = this.runGit('git log -n 50 --format="%H|%P|%s"');
+      const lines = logOutput.split("\n").filter(Boolean);
+
+      const commits = lines.map((line) => {
+        const parts = line.split("|");
+        const hash = parts[0] || "";
+        const parentsStr = parts[1] || "";
+        const parents = parentsStr.split(" ").filter(Boolean);
+        const subject = parts[2] || "";
+        return { hash, parents, subject };
+      });
+
+      // 1. Enforce that any commit containing merge-like patterns in its subject must have at least 2 parents
+      for (const commit of commits) {
+        const isMergeSubject = /merge\b/i.test(commit.subject) || /pull request/i.test(commit.subject);
+        if (isMergeSubject && commit.parents.length < 2) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Linear or fast-forward merge detected for commit '${commit.hash.slice(0, 7)}' ("${commit.subject}"). Merges into integration branches must use the non-fast-forward (--no-ff) strategy to preserve topology.`
+          };
+        }
+      }
+
+      // 2. If the current branch is an integration branch, ensure it contains at least one merge commit (2+ parents)
+      // to establish non-linear history, unless the repository has very few commits (e.g. initial setup).
+      const isIntegrationBranch = ["main", "master"].includes(branchName) || String(branchName).startsWith("release");
+      if (isIntegrationBranch && commits.length > 5) {
+        const hasMergeCommit = commits.some((c) => c.parents.length >= 2);
+        if (!hasMergeCommit) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Integration branch '${branchName}' has a purely linear commit history. Integrated branches must use non-fast-forward (--no-ff) merges to preserve feature branches.`
+          };
+        }
+      }
+
+      return { status: "PASS" };
+    } catch (error) {
+      // If we are not inside a git repo or git is not available, we fail-closed or report error
+      return {
+        status: "ERROR",
+        reason: `Failed to check merge integrity: ${error.message}`
+      };
+    }
+  }
+}

package/src/core/healing/healer-engine.js

@@ -36,11 +36,12 @@ function collectBlockingFindings(result = {}) {
 }
 
 export class HealerEngine {
-  constructor({ cwd, mode = "standard", taskSlug = "implementation", maxAttempts = null } = {}) {
+  constructor({ cwd, mode = "standard", taskSlug = "implementation", maxAttempts = null, ledger = null } = {}) {
     this.cwd = cwd;
     this.mode = MODE_ATTEMPTS[mode] ? mode : "standard";
     this.taskSlug = taskSlug;
     this.maxAttempts = maxAttempts ?? MODE_ATTEMPTS[this.mode];
+    this.ledger = ledger;
   }
 
   get statePath() {
@@ -139,6 +140,38 @@ export class HealerEngine {
 
       const next = await validate({ affectedChecks: this.affectedChecks(current), attempt });
       const progress = this.hasProgress(current, next, remediation);
+
+      // Verify strict conditions to declare Phoenix remediation applied/completed
+      const findingsConcrete = this.affectedChecks(current).length > 0;
+      const hashAltered = remediation.changedFiles && remediation.changedFiles.length > 0;
+      const inScope = hashAltered && remediation.changedFiles.every(file => {
+        const norm = file.replaceAll("\\", "/");
+        if (norm.startsWith(".ai-workflow/")) return false;
+        if (norm === "package.json" || norm === "package-lock.json" || norm === "tsconfig.json" || norm === ".gitignore" || norm === "opencode.jsonc" || norm === "EVIDENCE.json") {
+          return false;
+        }
+        return true;
+      });
+      const validationPassed = next.overallStatus === "PASS" || next.overallStatus === "PASS_WITH_NOTES";
+
+      const phoenixSuccessful = findingsConcrete && hashAltered && inScope && validationPassed;
+
+      if (this.ledger && phoenixSuccessful) {
+        this.ledger.logEvent({
+          actor: "Phoenix",
+          actorType: "runtime-agent",
+          observed: true,
+          runtime: "opencode",
+          eventType: "remediation_complete",
+          provenance: "opencode-adapter",
+          data: {
+            success: true,
+            changedFiles: remediation.changedFiles,
+            event: "remediation.completed"
+          }
+        });
+      }
+
       history.push({
         attempt,
         before: current.overallStatus,