@xn-intenton-z2a/agentic-lib 7.2.5 → 7.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xn-intenton-z2a/agentic-lib",
-  "version": "7.2.5",
+  "version": "7.2.7",
   "description": "Agentic-lib Agentic Coding Systems SDK powering automated GitHub workflows.",
   "type": "module",
   "scripts": {
@@ -72,6 +72,7 @@
     "bin/",
     "src/dist-transform.js",
     "src/iterate.js",
+    "src/copilot/",
     ".github/workflows/agentic-lib-*.yml",
     "agentic-lib.toml",
     "src/actions/agentic-step/*.js",

package/src/actions/agentic-step/config-loader.js

@@ -257,6 +257,14 @@ export function loadConfig(configPath) {
   const execution = toml.execution || {};
   const bot = toml.bot || {};
 
+  // Mission-complete thresholds (with safe defaults)
+  const mc = toml["mission-complete"] || {};
+  const missionCompleteThresholds = {
+    minResolvedIssues: mc["min-resolved-issues"] ?? 3,
+    requireDedicatedTests: mc["require-dedicated-tests"] ?? true,
+    maxSourceTodos: mc["max-source-todos"] ?? 0,
+  };
+
   return {
     supervisor: toml.schedule?.supervisor || "daily",
     model: toml.tuning?.model || toml.schedule?.model || "gpt-5-mini",
@@ -274,6 +282,7 @@ export function loadConfig(configPath) {
     },
     init: toml.init || null,
     tdd: toml.tdd === true,
+    missionCompleteThresholds,
     writablePaths,
     readOnlyPaths,
     configToml: rawToml,

package/src/actions/agentic-step/index.js

@@ -9,7 +9,8 @@ import * as core from "@actions/core";
 import * as github from "@actions/github";
 import { loadConfig, getWritablePaths } from "./config-loader.js";
 import { logActivity, generateClosingNotes } from "./logging.js";
-import { readFileSync, existsSync, readdirSync } from "fs";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
 
 // Task implementations
 import { resolveIssue } from "./tasks/resolve-issue.js";
@@ -21,6 +22,7 @@ import { enhanceIssue } from "./tasks/enhance-issue.js";
 import { reviewIssue } from "./tasks/review-issue.js";
 import { discussions } from "./tasks/discussions.js";
 import { supervise } from "./tasks/supervise.js";
+import { direct } from "./tasks/direct.js";
 
 const TASKS = {
   "resolve-issue": resolveIssue,
@@ -32,8 +34,38 @@ const TASKS = {
   "review-issue": reviewIssue,
   "discussions": discussions,
   "supervise": supervise,
+  "direct": direct,
 };
 
+/**
+ * Recursively count TODO/FIXME comments in source files under a directory.
+ * @param {string} dir - Directory to scan
+ * @param {string[]} [extensions] - File extensions to include (default: .js, .ts, .mjs)
+ * @returns {number} Total count of TODO/FIXME occurrences
+ */
+export function countSourceTodos(dir, extensions = [".js", ".ts", ".mjs"]) {
+  let count = 0;
+  if (!existsSync(dir)) return 0;
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry.startsWith(".")) continue;
+      const fullPath = join(dir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          count += countSourceTodos(fullPath, extensions);
+        } else if (extensions.some((ext) => entry.endsWith(ext))) {
+          const content = readFileSync(fullPath, "utf8");
+          const matches = content.match(/\bTODO\b/gi);
+          if (matches) count += matches.length;
+        }
+      } catch { /* skip unreadable files */ }
+    }
+  } catch { /* skip unreadable dirs */ }
+  return count;
+}
+
 /**
  * Build mission-complete metrics array for the intentïon.md dashboard.
  */
@@ -47,10 +79,28 @@ function buildMissionMetrics(config, result, limitsStatus, cumulativeCost, featu
   // Count open PRs from result if available
   const openPrs = result.openPrCount || 0;
 
+  // W9: Count TODO comments in source directory
+  const sourcePath = config.paths?.source?.path || "src/lib/";
+  const sourceDir = sourcePath.endsWith("/") ? sourcePath.slice(0, -1) : sourcePath;
+  // Scan the parent src/ directory to catch all source TODOs
+  const srcRoot = sourceDir.includes("/") ? sourceDir.split("/").slice(0, -1).join("/") || "src" : "src";
+  const todoCount = countSourceTodos(srcRoot);
+
+  // W3: Check for dedicated test files
+  const hasDedicatedTests = result.hasDedicatedTests ?? false;
+
+  // W11: Thresholds from config
+  const thresholds = config.missionCompleteThresholds || {};
+  const minResolved = thresholds.minResolvedIssues ?? 3;
+  const requireTests = thresholds.requireDedicatedTests ?? true;
+  const maxTodos = thresholds.maxSourceTodos ?? 0;
+
   const metrics = [
     { metric: "Open issues", value: String(openIssues), target: "0", status: openIssues === 0 ? "MET" : "NOT MET" },
     { metric: "Open PRs", value: String(openPrs), target: "0", status: openPrs === 0 ? "MET" : "NOT MET" },
-    { metric: "Issues resolved (review or PR merge)", value: String(resolvedCount), target: ">= 1", status: resolvedCount >= 1 ? "MET" : "NOT MET" },
+    { metric: "Issues resolved (review or PR merge)", value: String(resolvedCount), target: `>= ${minResolved}`, status: resolvedCount >= minResolved ? "MET" : "NOT MET" },
+    { metric: "Dedicated test files", value: hasDedicatedTests ? "YES" : "NO", target: requireTests ? "YES" : "—", status: !requireTests || hasDedicatedTests ? "MET" : "NOT MET" },
+    { metric: "Source TODO count", value: String(todoCount), target: `<= ${maxTodos}`, status: todoCount <= maxTodos ? "MET" : "NOT MET" },
     { metric: "Transformation budget used", value: `${cumulativeCost}/${budgetCap}`, target: budgetCap > 0 ? `< ${budgetCap}` : "unlimited", status: budgetCap > 0 && cumulativeCost >= budgetCap ? "EXHAUSTED" : "OK" },
     { metric: "Cumulative transforms", value: String(cumulativeCost), target: ">= 1", status: cumulativeCost >= 1 ? "MET" : "NOT MET" },
     { metric: "Mission complete declared", value: missionComplete ? "YES" : "NO", target: "—", status: "—" },
@@ -67,6 +117,8 @@ function buildMissionReadiness(metrics) {
   const openIssues = parseInt(metrics.find((m) => m.metric === "Open issues")?.value || "0", 10);
   const openPrs = parseInt(metrics.find((m) => m.metric === "Open PRs")?.value || "0", 10);
   const resolved = parseInt(metrics.find((m) => m.metric === "Issues resolved (review or PR merge)")?.value || "0", 10);
+  const hasDedicatedTests = metrics.find((m) => m.metric === "Dedicated test files")?.value === "YES";
+  const todoCount = parseInt(metrics.find((m) => m.metric === "Source TODO count")?.value || "0", 10);
   const missionComplete = metrics.find((m) => m.metric === "Mission complete declared")?.value === "YES";
   const missionFailed = metrics.find((m) => m.metric === "Mission failed declared")?.value === "YES";
 
@@ -77,17 +129,23 @@ function buildMissionReadiness(metrics) {
     return "Mission has been declared failed.";
   }
 
-  const conditionsMet = openIssues === 0 && openPrs === 0 && resolved >= 1;
+  // Check all NOT MET conditions
+  const notMet = metrics.filter((m) => m.status === "NOT MET");
+  const allMet = notMet.length === 0;
   const parts = [];
 
-  if (conditionsMet) {
+  if (allMet) {
     parts.push("Mission complete conditions ARE met.");
-    parts.push(`0 open issues, 0 open PRs, ${resolved} issue(s) resolved.`);
+    parts.push(`0 open issues, 0 open PRs, ${resolved} issue(s) resolved, dedicated tests: ${hasDedicatedTests ? "yes" : "no"}, TODOs: ${todoCount}.`);
   } else {
     parts.push("Mission complete conditions are NOT met.");
     if (openIssues > 0) parts.push(`${openIssues} open issue(s) remain.`);
     if (openPrs > 0) parts.push(`${openPrs} open PR(s) remain.`);
-    if (resolved < 1) parts.push("No issues have been resolved yet.");
+    for (const m of notMet) {
+      if (m.metric !== "Open issues" && m.metric !== "Open PRs") {
+        parts.push(`${m.metric}: ${m.value} (target: ${m.target}).`);
+      }
+    }
   }
 
   return parts.join(" ");
@@ -166,9 +224,23 @@ async function run() {
     const profileName = config.tuning?.profileName || "unknown";
 
     // Transformation cost: 1 for code-changing tasks, 0 otherwise
+    // W4: Instability transforms (infrastructure fixes) don't count against mission budget
     const COST_TASKS = ["transform", "fix-code", "maintain-features", "maintain-library"];
     const isNop = result.outcome === "nop" || result.outcome === "error";
-    const transformationCost = COST_TASKS.includes(task) && !isNop ? 1 : 0;
+    let isInstabilityTransform = false;
+    if (issueNumber && COST_TASKS.includes(task) && !isNop) {
+      try {
+        const { data: issueData } = await context.octokit.rest.issues.get({
+          ...context.repo,
+          issue_number: Number(issueNumber),
+        });
+        isInstabilityTransform = issueData.labels.some((l) => l.name === "instability");
+        if (isInstabilityTransform) {
+          core.info(`Issue #${issueNumber} has instability label — transform does not count against mission budget`);
+        }
+      } catch { /* ignore — conservative: count as mission transform */ }
+    }
+    const transformationCost = COST_TASKS.includes(task) && !isNop && !isInstabilityTransform ? 1 : 0;
 
     // Read cumulative transformation cost from the activity log
     const intentionFilepath = config.intentionBot?.intentionFilepath;
@@ -190,6 +262,31 @@ async function run() {
       ? readdirSync(libraryPath).filter((f) => f.endsWith(".md")).length
       : 0;
 
+    // W3/W10: Detect dedicated test files (centrally, for all tasks)
+    let hasDedicatedTests = result.hasDedicatedTests ?? false;
+    if (!hasDedicatedTests) {
+      try {
+        const { scanDirectory: scanDir } = await import("./copilot.js");
+        const testDirs = ["tests", "__tests__"];
+        for (const dir of testDirs) {
+          if (existsSync(dir)) {
+            const testFiles = scanDir(dir, [".js", ".ts", ".mjs"], { limit: 20 });
+            for (const tf of testFiles) {
+              if (/^(main|web|behaviour)\.test\.[jt]s$/.test(tf.name)) continue;
+              const content = readFileSync(tf.path, "utf8");
+              if (/from\s+['"].*src\/lib\//.test(content) || /require\s*\(\s*['"].*src\/lib\//.test(content)) {
+                hasDedicatedTests = true;
+                break;
+              }
+            }
+            if (hasDedicatedTests) break;
+          }
+        }
+      } catch { /* ignore — scanDirectory not available in test environment */ }
+    }
+    // Inject hasDedicatedTests into result for buildMissionMetrics
+    result.hasDedicatedTests = hasDedicatedTests;
+
     // Count open automated issues (feature vs maintenance)
     let featureIssueCount = 0;
     let maintenanceIssueCount = 0;

package/src/actions/agentic-step/tasks/direct.js

@@ -0,0 +1,435 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2025-2026 Polycode Limited
+// tasks/direct.js — Director: mission-complete/failed evaluation via LLM
+//
+// Gathers mission metrics, builds an advisory assessment, asks the LLM
+// to decide mission-complete, mission-failed, or produce a gap analysis.
+// The director does NOT dispatch workflows or create issues — that's the supervisor's job.
+
+import * as core from "@actions/core";
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { runCopilotTask, readOptionalFile, scanDirectory, filterIssues } from "../copilot.js";
+
+/**
+ * Count TODO comments recursively in a directory.
+ */
+function countTodos(dir) {
+  let n = 0;
+  if (!existsSync(dir)) return 0;
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry.startsWith(".")) continue;
+      const fp = `${dir}/${entry}`;
+      try {
+        const stat = statSync(fp);
+        if (stat.isDirectory()) {
+          n += countTodos(fp);
+        } else if (/\.(js|ts|mjs)$/.test(entry)) {
+          const content = readFileSync(fp, "utf8");
+          const m = content.match(/\bTODO\b/gi);
+          if (m) n += m.length;
+        }
+      } catch { /* skip */ }
+    }
+  } catch { /* skip */ }
+  return n;
+}
+
+/**
+ * Detect dedicated test files that import from src/lib/.
+ */
+function detectDedicatedTests() {
+  let hasDedicatedTests = false;
+  const dedicatedTestFiles = [];
+  const testDirs = ["tests", "__tests__"];
+  for (const dir of testDirs) {
+    if (existsSync(dir)) {
+      try {
+        const testFiles = scanDirectory(dir, [".js", ".ts", ".mjs"], { limit: 20 });
+        for (const tf of testFiles) {
+          if (/^(main|web|behaviour)\.test\.[jt]s$/.test(tf.name)) continue;
+          const content = readFileSync(tf.path, "utf8");
+          if (/from\s+['"].*src\/lib\//.test(content) || /require\s*\(\s*['"].*src\/lib\//.test(content)) {
+            hasDedicatedTests = true;
+            dedicatedTestFiles.push(tf.name);
+          }
+        }
+      } catch { /* ignore */ }
+    }
+  }
+  return { hasDedicatedTests, dedicatedTestFiles };
+}
+
+/**
+ * Build the metric-based mission-complete advisory string.
+ * This is the mechanical check — purely rule-based, no LLM.
+ */
+function buildMetricAssessment(ctx, config) {
+  const thresholds = config.missionCompleteThresholds || {};
+  const minResolved = thresholds.minResolvedIssues ?? 3;
+  const requireTests = thresholds.requireDedicatedTests ?? true;
+  const maxTodos = thresholds.maxSourceTodos ?? 0;
+
+  const metrics = [
+    { metric: "Open issues", value: ctx.issuesSummary.length, target: 0, met: ctx.issuesSummary.length === 0 },
+    { metric: "Open PRs", value: ctx.prsSummary.length, target: 0, met: ctx.prsSummary.length === 0 },
+    { metric: "Issues resolved", value: ctx.resolvedCount, target: minResolved, met: ctx.resolvedCount >= minResolved },
+    { metric: "Dedicated tests", value: ctx.hasDedicatedTests ? "YES" : "NO", target: requireTests ? "YES" : "—", met: !requireTests || ctx.hasDedicatedTests },
+    { metric: "Source TODOs", value: ctx.sourceTodoCount, target: maxTodos, met: ctx.sourceTodoCount <= maxTodos },
+    { metric: "Budget", value: ctx.cumulativeTransformationCost, target: ctx.transformationBudget || "unlimited", met: !(ctx.transformationBudget > 0 && ctx.cumulativeTransformationCost >= ctx.transformationBudget) },
+  ];
+
+  const allMet = metrics.every((m) => m.met);
+  const notMet = metrics.filter((m) => !m.met);
+
+  const table = [
+    "| Metric | Value | Target | Status |",
+    "|--------|-------|--------|--------|",
+    ...metrics.map((m) => `| ${m.metric} | ${m.value} | ${typeof m.target === "number" ? (m.metric.includes("TODO") ? `<= ${m.target}` : m.metric.includes("resolved") ? `>= ${m.target}` : `${m.target}`) : m.target} | ${m.met ? "MET" : "NOT MET"} |`),
+  ].join("\n");
+
+  let assessment;
+  if (allMet) {
+    assessment = "ALL METRICS MET — mission-complete conditions are satisfied.";
+  } else {
+    assessment = `${notMet.length} metric(s) NOT MET: ${notMet.map((m) => `${m.metric}=${m.value}`).join(", ")}.`;
+  }
+
+  return { metrics, allMet, notMet, table, assessment };
+}
+
+/**
+ * Build the director prompt.
+ */
+function buildPrompt(ctx, agentInstructions, metricAssessment) {
+  return [
+    "## Instructions",
+    agentInstructions,
+    "",
+    "## Mission",
+    ctx.mission || "(no mission defined)",
+    "",
+    "## Metric Based Mission Complete Assessment",
+    metricAssessment.assessment,
+    "",
+    "### Mission-Complete Metrics",
+    metricAssessment.table,
+    "",
+    "## Repository State",
+    `### Open Issues (${ctx.issuesSummary.length})`,
+    ctx.issuesSummary.join("\n") || "none",
+    "",
+    `### Recently Closed Issues (${ctx.recentlyClosedSummary.length})`,
+    ctx.recentlyClosedSummary.join("\n") || "none",
+    "",
+    `### Open PRs (${ctx.prsSummary.length})`,
+    ctx.prsSummary.join("\n") || "none",
+    "",
+    ...(ctx.sourceExports?.length > 0
+      ? [
+          `### Source Exports`,
+          ...ctx.sourceExports.map((e) => `- ${e}`),
+          "",
+        ]
+      : []),
+    `### Test Coverage`,
+    ctx.hasDedicatedTests
+      ? `Dedicated test files: ${ctx.dedicatedTestFiles.join(", ")}`
+      : "**No dedicated test files found.**",
+    "",
+    `### Source TODO Count: ${ctx.sourceTodoCount}`,
+    "",
+    `### Transformation Budget: ${ctx.cumulativeTransformationCost}/${ctx.transformationBudget || "unlimited"}`,
+    "",
+    `### Recent Activity`,
+    ctx.recentActivity || "none",
+    "",
+  ].join("\n");
+}
+
+/**
+ * Parse the director's LLM response.
+ */
+function parseDirectorResponse(content) {
+  const decisionMatch = content.match(/\[DECISION\]([\s\S]*?)\[\/DECISION\]/);
+  const reasonMatch = content.match(/\[REASON\]([\s\S]*?)\[\/REASON\]/);
+  const analysisMatch = content.match(/\[ANALYSIS\]([\s\S]*?)\[\/ANALYSIS\]/);
+
+  const decision = decisionMatch ? decisionMatch[1].trim().toLowerCase() : "in-progress";
+  const reason = reasonMatch ? reasonMatch[1].trim() : "";
+  const analysis = analysisMatch ? analysisMatch[1].trim() : content.substring(0, 500);
+
+  return { decision, reason, analysis };
+}
+
+/**
+ * Execute mission-complete: write signal file and commit via Contents API.
+ */
+async function executeMissionComplete(octokit, repo, reason) {
+  const signal = [
+    "# Mission Complete",
+    "",
+    `- **Timestamp:** ${new Date().toISOString()}`,
+    `- **Detected by:** director`,
+    `- **Reason:** ${reason}`,
+    "",
+    "This file was created automatically. To restart transformations, delete this file or run `npx @xn-intenton-z2a/agentic-lib init --reseed`.",
+  ].join("\n");
+  writeFileSync("MISSION_COMPLETE.md", signal);
+
+  try {
+    const contentBase64 = Buffer.from(signal).toString("base64");
+    let existingSha;
+    try {
+      const { data } = await octokit.rest.repos.getContent({ ...repo, path: "MISSION_COMPLETE.md", ref: "main" });
+      existingSha = data.sha;
+    } catch { /* doesn't exist yet */ }
+    await octokit.rest.repos.createOrUpdateFileContents({
+      ...repo,
+      path: "MISSION_COMPLETE.md",
+      message: "mission-complete: " + reason.substring(0, 72),
+      content: contentBase64,
+      branch: "main",
+      ...(existingSha ? { sha: existingSha } : {}),
+    });
+    core.info("MISSION_COMPLETE.md committed to main");
+  } catch (err) {
+    core.warning(`Could not commit MISSION_COMPLETE.md: ${err.message}`);
+  }
+}
+
+/**
+ * Execute mission-failed: write signal file and commit via Contents API.
+ */
+async function executeMissionFailed(octokit, repo, reason) {
+  const signal = [
+    "# Mission Failed",
+    "",
+    `- **Timestamp:** ${new Date().toISOString()}`,
+    `- **Detected by:** director`,
+    `- **Reason:** ${reason}`,
+    "",
+    "This file was created automatically. To restart, delete this file and run `npx @xn-intenton-z2a/agentic-lib init --reseed`.",
+  ].join("\n");
+  writeFileSync("MISSION_FAILED.md", signal);
+
+  try {
+    const contentBase64 = Buffer.from(signal).toString("base64");
+    let existingSha;
+    try {
+      const { data } = await octokit.rest.repos.getContent({ ...repo, path: "MISSION_FAILED.md", ref: "main" });
+      existingSha = data.sha;
+    } catch { /* doesn't exist yet */ }
+    await octokit.rest.repos.createOrUpdateFileContents({
+      ...repo,
+      path: "MISSION_FAILED.md",
+      message: "mission-failed: " + reason.substring(0, 72),
+      content: contentBase64,
+      branch: "main",
+      ...(existingSha ? { sha: existingSha } : {}),
+    });
+    core.info("MISSION_FAILED.md committed to main");
+  } catch (err) {
+    core.warning(`Could not commit MISSION_FAILED.md: ${err.message}`);
+  }
+}
+
+/**
+ * Director task: evaluate mission readiness and produce a decision or gap analysis.
+ *
+ * @param {Object} context - Task context from index.js
+ * @returns {Promise<Object>} Result with outcome, tokensUsed, model
+ */
+export async function direct(context) {
+  const { octokit, repo, config, instructions, model } = context;
+  const t = config.tuning || {};
+
+  // --- Gather context (similar to supervisor but focused on metrics) ---
+  const mission = readOptionalFile(config.paths.mission.path);
+  const intentionLogFull = readOptionalFile(config.intentionBot.intentionFilepath);
+  const recentActivity = intentionLogFull.split("\n").slice(-20).join("\n");
+
+  const costMatches = intentionLogFull.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+  const cumulativeTransformationCost = [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+
+  const missionComplete = existsSync("MISSION_COMPLETE.md");
+  const missionFailed = existsSync("MISSION_FAILED.md");
+  const transformationBudget = config.transformationBudget || 0;
+
+  // If already decided, skip
+  if (missionComplete) {
+    return { outcome: "nop", details: "Mission already complete (MISSION_COMPLETE.md exists)" };
+  }
+  if (missionFailed) {
+    return { outcome: "nop", details: "Mission already failed (MISSION_FAILED.md exists)" };
+  }
+
+  // Skip in maintenance mode
+  if (config.supervisor === "maintenance") {
+    return { outcome: "nop", details: "Maintenance mode — director skipped" };
+  }
+
+  const initTimestamp = config.init?.timestamp || null;
+
+  const { data: openIssues } = await octokit.rest.issues.listForRepo({
+    ...repo, state: "open", per_page: t.issuesScan || 20, sort: "created", direction: "asc",
+  });
+  const issuesOnly = openIssues.filter((i) => !i.pull_request);
+  const filteredIssues = filterIssues(issuesOnly, { staleDays: t.staleDays || 30, initTimestamp });
+  const issuesSummary = filteredIssues.map((i) => {
+    const labels = i.labels.map((l) => l.name).join(", ");
+    return `#${i.number}: ${i.title} [${labels || "no labels"}]`;
+  });
+
+  // Recently closed issues
+  let recentlyClosedSummary = [];
+  let resolvedCount = 0;
+  try {
+    const { data: closedIssuesRaw } = await octokit.rest.issues.listForRepo({
+      ...repo, state: "closed", labels: "automated", per_page: 10, sort: "updated", direction: "desc",
+    });
+    const initEpoch = initTimestamp ? new Date(initTimestamp).getTime() : 0;
+    const closedFiltered = closedIssuesRaw.filter((i) =>
+      !i.pull_request && (initEpoch <= 0 || new Date(i.created_at).getTime() >= initEpoch)
+    );
+    for (const ci of closedFiltered) {
+      let closeReason = "closed";
+      try {
+        const { data: comments } = await octokit.rest.issues.listComments({
+          ...repo, issue_number: ci.number, per_page: 5, sort: "created", direction: "desc",
+        });
+        if (comments.some((c) => c.body?.includes("Automated Review Result"))) {
+          closeReason = "RESOLVED";
+        } else {
+          const { data: events } = await octokit.rest.issues.listEvents({
+            ...repo, issue_number: ci.number, per_page: 10,
+          });
+          if (events.some((e) => e.event === "closed" && e.commit_id)) {
+            closeReason = "RESOLVED";
+          }
+        }
+        // Check for automerge closure (issue has "merged" label — set by ci-automerge)
+        if (closeReason !== "RESOLVED") {
+          const issueLabels = ci.labels.map((l) => (typeof l === "string" ? l : l.name));
+          if (issueLabels.includes("merged")) {
+            closeReason = "RESOLVED";
+          }
+        }
+      } catch { /* ignore */ }
+      if (closeReason === "RESOLVED") resolvedCount++;
+      recentlyClosedSummary.push(`#${ci.number}: ${ci.title} — ${closeReason}`);
+    }
+  } catch (err) {
+    core.warning(`Could not fetch recently closed issues: ${err.message}`);
+  }
+
+  // Open PRs
+  const { data: openPRs } = await octokit.rest.pulls.list({
+    ...repo, state: "open", per_page: 10, sort: "updated", direction: "desc",
+  });
+  const prsSummary = openPRs.map((pr) => `#${pr.number}: ${pr.title} (${pr.head.ref})`);
+
+  // Source exports
+  let sourceExports = [];
+  try {
+    const sourcePath = config.paths.source?.path || "src/lib/";
+    if (existsSync(sourcePath)) {
+      const sourceFiles = scanDirectory(sourcePath, [".js", ".ts"], { limit: 5 });
+      for (const sf of sourceFiles) {
+        const content = readFileSync(sf.path, "utf8");
+        const exports = [...content.matchAll(/export\s+(?:async\s+)?(?:function|const|let|var|class)\s+(\w+)/g)]
+          .map((m) => m[1]);
+        if (exports.length > 0) {
+          sourceExports.push(`${sf.name}: ${exports.join(", ")}`);
+        }
+      }
+    }
+  } catch { /* ignore */ }
+
+  // Dedicated tests
+  const { hasDedicatedTests, dedicatedTestFiles } = detectDedicatedTests();
+
+  // TODO count
+  const sourcePath = config.paths.source?.path || "src/lib/";
+  const sourceDir = sourcePath.endsWith("/") ? sourcePath.slice(0, -1) : sourcePath;
+  const srcRoot = sourceDir.includes("/") ? sourceDir.split("/").slice(0, -1).join("/") || "src" : "src";
+  const sourceTodoCount = countTodos(srcRoot);
+
+  // Build context
+  const ctx = {
+    mission,
+    recentActivity,
+    issuesSummary,
+    recentlyClosedSummary,
+    resolvedCount,
+    prsSummary,
+    sourceExports,
+    hasDedicatedTests,
+    dedicatedTestFiles,
+    sourceTodoCount,
+    cumulativeTransformationCost,
+    transformationBudget,
+  };
+
+  // Build metric-based advisory
+  const metricAssessment = buildMetricAssessment(ctx, config);
+  core.info(`Metric assessment: ${metricAssessment.assessment}`);
+
+  // --- LLM decision ---
+  const agentInstructions = instructions || "You are the director. Evaluate mission readiness.";
+  const prompt = buildPrompt(ctx, agentInstructions, metricAssessment);
+
+  const { content, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
+    model,
+    systemMessage:
+      "You are the director of an autonomous coding repository. Your job is to evaluate whether the mission is complete, failed, or in progress. You produce a structured assessment — you do NOT dispatch workflows or create issues.",
+    prompt,
+    writablePaths: [],
+    tuning: t,
+  });
+
+  const { decision, reason, analysis } = parseDirectorResponse(content);
+  core.info(`Director decision: ${decision} — ${reason}`);
+
+  // Execute the decision
+  let outcome = "directed";
+  if (decision === "mission-complete" && metricAssessment.allMet) {
+    if (process.env.GITHUB_REPOSITORY !== "xn-intenton-z2a/agentic-lib") {
+      await executeMissionComplete(octokit, repo, reason);
+      outcome = "mission-complete";
+    }
+  } else if (decision === "mission-complete" && !metricAssessment.allMet) {
+    core.info("Director chose mission-complete but metrics are NOT all met — overriding to in-progress");
+    outcome = "directed";
+  } else if (decision === "mission-failed") {
+    if (process.env.GITHUB_REPOSITORY !== "xn-intenton-z2a/agentic-lib") {
+      await executeMissionFailed(octokit, repo, reason);
+      outcome = "mission-failed";
+    }
+  }
+
+  // Set output for downstream jobs to check
+  core.setOutput("director-decision", decision);
+  core.setOutput("director-analysis", analysis.substring(0, 500));
+
+  return {
+    outcome,
+    tokensUsed,
+    inputTokens,
+    outputTokens,
+    cost,
+    model,
+    details: `Decision: ${decision}\nReason: ${reason}\nAnalysis: ${analysis.substring(0, 300)}`,
+    narrative: `Director: ${reason}`,
+    metricAssessment: metricAssessment.assessment,
+    directorAnalysis: analysis,
+    hasDedicatedTests,
+    resolvedCount,
+    changes: outcome === "mission-complete"
+      ? [{ action: "mission-complete", file: "MISSION_COMPLETE.md", sizeInfo: reason.substring(0, 100) }]
+      : outcome === "mission-failed"
+        ? [{ action: "mission-failed", file: "MISSION_FAILED.md", sizeInfo: reason.substring(0, 100) }]
+        : [],
+  };
+}