@xn-intenton-z2a/agentic-lib 7.4.5 → 7.4.7

package/src/copilot/telemetry.js

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Copyright (C) 2025-2026 Polycode Limited
+// telemetry.js — Mission metrics, readiness narrative, and cost tracking
+//
+// Phase 4: Extracted from src/actions/agentic-step/index.js so that both
+// CLI and Actions share the same metric calculation logic.
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+
+/**
+ * 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.
+ *
+ * @param {Object} config - Parsed agentic-lib config
+ * @param {Object} result - Task result object
+ * @param {Array} _limitsStatus - Limits status array (unused but kept for signature compatibility)
+ * @param {number} cumulativeCost - Cumulative transformation cost
+ * @param {number} featureIssueCount - Number of open feature issues
+ * @param {number} maintenanceIssueCount - Number of open maintenance issues
+ * @returns {Array} Mission metrics entries
+ */
+export function buildMissionMetrics(config, result, _limitsStatus, cumulativeCost, featureIssueCount, maintenanceIssueCount) {
+  const openIssues = featureIssueCount + maintenanceIssueCount;
+  const budgetCap = config.transformationBudget || 0;
+  const resolvedCount = result.resolvedCount || 0;
+  const missionComplete = existsSync("MISSION_COMPLETE.md");
+  const missionFailed = existsSync("MISSION_FAILED.md");
+  const openPrs = result.openPrCount || 0;
+
+  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 todoCount = countSourceTodos(srcRoot);
+
+  const dedicatedTestCount = result.dedicatedTestCount ?? 0;
+
+  const thresholds = config.missionCompleteThresholds || {};
+  const minResolved = thresholds.minResolvedIssues ?? 3;
+  const minTests = thresholds.minDedicatedTests ?? 1;
+  const maxTodos = thresholds.maxSourceTodos ?? 0;
+
+  return [
+    { 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: `>= ${minResolved}`, status: resolvedCount >= minResolved ? "MET" : "NOT MET" },
+    { metric: "Dedicated test files", value: String(dedicatedTestCount), target: `>= ${minTests}`, status: dedicatedTestCount >= minTests ? "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: "—" },
+    { metric: "Mission failed declared", value: missionFailed ? "YES" : "NO", target: "—", status: "—" },
+  ];
+}
+
+/**
+ * Build mission-complete readiness narrative from metrics.
+ *
+ * @param {Array} metrics - Mission metrics from buildMissionMetrics()
+ * @returns {string} Readiness narrative
+ */
+export 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 dedicatedTests = parseInt(metrics.find((m) => m.metric === "Dedicated test files")?.value || "0", 10);
+  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";
+
+  if (missionComplete) return "Mission has been declared complete.";
+  if (missionFailed) return "Mission has been declared failed.";
+
+  const notMet = metrics.filter((m) => m.status === "NOT MET");
+  const allMet = notMet.length === 0;
+  const parts = [];
+
+  if (allMet) {
+    parts.push("Mission complete conditions ARE met.");
+    parts.push(`0 open issues, 0 open PRs, ${resolved} issue(s) resolved, ${dedicatedTests} dedicated test(s), 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.`);
+    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(" ");
+}
+
+/**
+ * Compute transformation cost for a task execution.
+ *
+ * @param {string} task - Task name
+ * @param {string} outcome - Task outcome
+ * @param {boolean} isInstabilityTransform - Whether this is an instability transform
+ * @returns {number} 0 or 1
+ */
+export function computeTransformationCost(task, outcome, isInstabilityTransform) {
+  const COST_TASKS = ["transform", "fix-code", "maintain-features", "maintain-library"];
+  const isNop = outcome === "nop" || outcome === "error";
+  return COST_TASKS.includes(task) && !isNop && !isInstabilityTransform ? 1 : 0;
+}
+
+/**
+ * Read cumulative transformation cost from the intentïon.md activity log.
+ *
+ * @param {string} intentionFilepath - Path to the intentïon.md file
+ * @returns {number} Cumulative cost
+ */
+export function readCumulativeCost(intentionFilepath) {
+  if (!intentionFilepath || !existsSync(intentionFilepath)) return 0;
+  const logContent = readFileSync(intentionFilepath, "utf8");
+  const costMatches = logContent.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+  return [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+}
+
+/**
+ * Build limits status array for activity logging.
+ *
+ * @param {Object} params
+ * @returns {Array} Limits status entries
+ */
+export function buildLimitsStatus({
+  task, cumulativeCost, config, featureIssueCount, maintenanceIssueCount, featuresUsed, libraryUsed,
+}) {
+  const budgetCap = config.transformationBudget || 0;
+  const featCap = config.paths?.features?.limit || 4;
+  const libCap = config.paths?.library?.limit || 32;
+
+  return [
+    { name: "transformation-budget", valueNum: cumulativeCost, capacityNum: budgetCap, value: `${cumulativeCost}/${budgetCap}`, remaining: `${Math.max(0, budgetCap - cumulativeCost)}`, status: cumulativeCost >= budgetCap && budgetCap > 0 ? "EXHAUSTED" : "" },
+    { name: "max-feature-issues", valueNum: featureIssueCount, capacityNum: config.featureDevelopmentIssuesWipLimit, value: `${featureIssueCount}/${config.featureDevelopmentIssuesWipLimit}`, remaining: `${Math.max(0, config.featureDevelopmentIssuesWipLimit - featureIssueCount)}`, status: "" },
+    { name: "max-maintenance-issues", valueNum: maintenanceIssueCount, capacityNum: config.maintenanceIssuesWipLimit, value: `${maintenanceIssueCount}/${config.maintenanceIssuesWipLimit}`, remaining: `${Math.max(0, config.maintenanceIssuesWipLimit - maintenanceIssueCount)}`, status: "" },
+    { name: "max-attempts-per-issue", valueNum: 0, capacityNum: config.attemptsPerIssue, value: `?/${config.attemptsPerIssue}`, remaining: "?", status: task === "resolve-issue" ? "" : "n/a" },
+    { name: "max-attempts-per-branch", valueNum: 0, capacityNum: config.attemptsPerBranch, value: `?/${config.attemptsPerBranch}`, remaining: "?", status: task === "fix-code" ? "" : "n/a" },
+    { name: "features", valueNum: featuresUsed, capacityNum: featCap, value: `${featuresUsed}/${featCap}`, remaining: `${Math.max(0, featCap - featuresUsed)}`, status: ["maintain-features", "transform"].includes(task) ? "" : "n/a" },
+    { name: "library", valueNum: libraryUsed, capacityNum: libCap, value: `${libraryUsed}/${libCap}`, remaining: `${Math.max(0, libCap - libraryUsed)}`, status: task === "maintain-library" ? "" : "n/a" },
+  ];
+}

package/src/seeds/zero-package.json

@@ -17,7 +17,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xn-intenton-z2a/agentic-lib": "^7.4.5"
+    "@xn-intenton-z2a/agentic-lib": "^7.4.7"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.0",

package/src/copilot/tasks/fix-code.js

@@ -1,73 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-// Copyright (C) 2025-2026 Polycode Limited
-// src/copilot/tasks/fix-code.js — Fix failing tests (shared)
-//
-// In CLI/local mode: runs tests, feeds failures to agent.
-// In Actions mode: can also resolve merge conflicts and PR check failures.
-
-import { execSync } from "child_process";
-import {
-  runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection,
-  extractNarrative, NARRATIVE_INSTRUCTION,
-} from "../session.js";
-import { defaultLogger } from "../logger.js";
-
-/**
- * Fix failing code — local mode (no GitHub context needed).
- * Runs tests, feeds failure output to the agent.
- */
-export async function fixCode(context) {
-  const { config, instructions, writablePaths, testCommand, model, logger = defaultLogger } = context;
-  const t = config.tuning || {};
-  const workDir = context.workingDirectory || process.cwd();
-
-  // Run tests to get failure output
-  let testOutput;
-  let testsPassed = false;
-  try {
-    testOutput = execSync(testCommand, { cwd: workDir, encoding: "utf8", timeout: 120000 });
-    testsPassed = true;
-  } catch (err) {
-    testOutput = `STDOUT:\n${err.stdout || ""}\nSTDERR:\n${err.stderr || ""}`;
-  }
-
-  if (testsPassed) {
-    logger.info("Tests already pass — nothing to fix");
-    return { outcome: "nop", details: "Tests already pass" };
-  }
-
-  const mission = readOptionalFile(config.paths.mission.path);
-  const sourceFiles = scanDirectory(config.paths.source.path, [".js", ".ts"], {
-    fileLimit: t.sourceScan || 10,
-    contentLimit: t.sourceContent || 5000,
-    recursive: true, sortByMtime: true, clean: true,
-  }, logger);
-
-  const agentInstructions = instructions || "Fix the failing tests by modifying the source code.";
-
-  const prompt = [
-    "## Instructions", agentInstructions, "",
-    ...(mission ? ["## Mission", mission, ""] : []),
-    "## Failing Test Output",
-    "```", testOutput.substring(0, 8000), "```", "",
-    `## Current Source Files (${sourceFiles.length})`,
-    ...sourceFiles.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``), "",
-    formatPathsSection(writablePaths, config.readOnlyPaths, config), "",
-    "## Constraints",
-    `- Run \`${testCommand}\` to validate your fixes`,
-    "- Make minimal changes to fix the failing tests",
-    "- Do not introduce new features — focus on making the build green",
-  ].join("\n");
-
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
-    model,
-    systemMessage: "You are an autonomous coding agent fixing failing tests. Analyze the error output and make minimal, targeted changes to fix it." + NARRATIVE_INSTRUCTION,
-    prompt, writablePaths, tuning: t, logger, workingDirectory: workDir,
-  });
-
-  return {
-    outcome: "fix-applied", tokensUsed, inputTokens, outputTokens, cost, model,
-    details: `Applied fix based on test failures`,
-    narrative: extractNarrative(resultContent, "Fixed failing tests."),
-  };
-}

package/src/copilot/tasks/maintain-features.js

@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-// Copyright (C) 2025-2026 Polycode Limited
-// src/copilot/tasks/maintain-features.js — Feature lifecycle (shared)
-
-import { existsSync } from "fs";
-import {
-  runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection,
-  extractFeatureSummary, extractNarrative, NARRATIVE_INSTRUCTION,
-} from "../session.js";
-import { defaultLogger } from "../logger.js";
-
-export async function maintainFeatures(context) {
-  const { config, instructions, writablePaths, model, logger = defaultLogger } = context;
-  const t = config.tuning || {};
-
-  if (existsSync("MISSION_COMPLETE.md") && config.supervisor !== "maintenance") {
-    return { outcome: "nop", details: "Mission already complete" };
-  }
-
-  const mission = readOptionalFile(config.paths.mission.path);
-  const featuresPath = config.paths.features.path;
-  const featureLimit = config.paths.features.limit;
-  const features = scanDirectory(featuresPath, ".md", { fileLimit: t.featuresScan || 10 }, logger);
-
-  features.sort((a, b) => {
-    const aInc = /- \[ \]/.test(a.content) ? 0 : 1;
-    const bInc = /- \[ \]/.test(b.content) ? 0 : 1;
-    return aInc - bInc || a.name.localeCompare(b.name);
-  });
-
-  const libraryDocs = scanDirectory(config.paths.library.path, ".md", { contentLimit: t.documentSummary || 1000 }, logger);
-
-  const prompt = [
-    "## Instructions", instructions || "Maintain the feature set by creating, updating, or pruning features.", "",
-    "## Mission", mission, "",
-    `## Current Features (${features.length}/${featureLimit} max)`,
-    ...features.map((f) => `### ${f.name}\n${f.content}`), "",
-    ...(libraryDocs.length > 0 ? [
-      `## Library Documents (${libraryDocs.length})`,
-      ...libraryDocs.map((d) => `### ${d.name}\n${d.content}`), "",
-    ] : []),
-    "## Your Task",
-    `1. Review each existing feature — delete if implemented or irrelevant.`,
-    `2. If fewer than ${featureLimit} features, create new ones aligned with the mission.`,
-    "3. Ensure each feature has clear, testable acceptance criteria.", "",
-    formatPathsSection(writablePaths, config.readOnlyPaths, config), "",
-    "## Constraints", `- Maximum ${featureLimit} feature files`,
-  ].join("\n");
-
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
-    model,
-    systemMessage: "You are a feature lifecycle manager. Create, update, and prune feature specification files to keep the project focused on its mission." + NARRATIVE_INSTRUCTION,
-    prompt, writablePaths, tuning: t, logger,
-  });
-
-  return {
-    outcome: "features-maintained", tokensUsed, inputTokens, outputTokens, cost, model,
-    details: `Maintained features (${features.length} existing, limit ${featureLimit})`,
-    narrative: extractNarrative(resultContent, `Maintained ${features.length} features.`),
-  };
-}

package/src/copilot/tasks/maintain-library.js

@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-// Copyright (C) 2025-2026 Polycode Limited
-// src/copilot/tasks/maintain-library.js — Library management (shared)
-
-import { existsSync } from "fs";
-import {
-  runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection,
-  extractNarrative, NARRATIVE_INSTRUCTION,
-} from "../session.js";
-import { defaultLogger } from "../logger.js";
-
-export async function maintainLibrary(context) {
-  const { config, instructions, writablePaths, model, logger = defaultLogger } = context;
-  const t = config.tuning || {};
-
-  if (existsSync("MISSION_COMPLETE.md") && config.supervisor !== "maintenance") {
-    logger.info("Mission complete — skipping library maintenance");
-    return { outcome: "nop", details: "Mission already complete" };
-  }
-
-  const sourcesPath = config.paths.librarySources.path;
-  const sources = readOptionalFile(sourcesPath);
-  const mission = readOptionalFile(config.paths.mission.path);
-  const hasUrls = /https?:\/\//.test(sources);
-
-  const libraryPath = config.paths.library.path;
-  const libraryLimit = config.paths.library.limit;
-  const libraryDocs = scanDirectory(libraryPath, ".md", { contentLimit: t.documentSummary || 500 }, logger);
-
-  let prompt;
-  if (!hasUrls) {
-    prompt = [
-      "## Instructions", instructions || "Maintain the library by updating documents from sources.", "",
-      "## Mission", mission || "(no mission)", "",
-      "## Current SOURCES.md", sources || "(empty)", "",
-      "## Your Task",
-      `Populate ${sourcesPath} with 3-8 relevant reference URLs.`, "",
-      formatPathsSection(writablePaths, config.readOnlyPaths, config),
-    ].join("\n");
-  } else {
-    prompt = [
-      "## Instructions", instructions || "Maintain the library by updating documents from sources.", "",
-      "## Sources", sources, "",
-      `## Current Library Documents (${libraryDocs.length}/${libraryLimit} max)`,
-      ...libraryDocs.map((d) => `### ${d.name}\n${d.content}`), "",
-      "## Your Task",
-      "1. Read each URL in SOURCES.md and extract technical content.",
-      "2. Create or update library documents.", "",
-      formatPathsSection(writablePaths, config.readOnlyPaths, config), "",
-      "## Constraints", `- Maximum ${libraryLimit} library documents`,
-    ].join("\n");
-  }
-
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
-    model,
-    systemMessage: "You are a knowledge librarian. Maintain a library of technical documents extracted from web sources." + NARRATIVE_INSTRUCTION,
-    prompt, writablePaths, tuning: t, logger,
-  });
-
-  return {
-    outcome: hasUrls ? "library-maintained" : "sources-discovered",
-    tokensUsed, inputTokens, outputTokens, cost, model,
-    details: hasUrls ? `Maintained library (${libraryDocs.length} docs)` : "Discovered sources from mission",
-    narrative: extractNarrative(resultContent, hasUrls ? "Maintained library." : "Discovered sources."),
-  };
-}

package/src/copilot/tasks/transform.js

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-// Copyright (C) 2025-2026 Polycode Limited
-// src/copilot/tasks/transform.js — Transform task (shared)
-//
-// Ported from src/actions/agentic-step/tasks/transform.js.
-// GitHub context (octokit, issues) is optional for local CLI use.
-
-import { existsSync } from "fs";
-import {
-  runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection,
-  filterIssues, summariseIssue, extractFeatureSummary, extractNarrative, NARRATIVE_INSTRUCTION,
-} from "../session.js";
-import { defaultLogger } from "../logger.js";
-
-export async function transform(context) {
-  const { config, instructions, writablePaths, testCommand, model, logger = defaultLogger } = context;
-  // octokit + repo are optional (absent in CLI mode)
-  const octokit = context.octokit || null;
-  const repo = context.repo || null;
-  const issueNumber = context.issueNumber || null;
-  const t = config.tuning || {};
-
-  const mission = readOptionalFile(config.paths.mission.path);
-  if (!mission) {
-    logger.warning(`No mission file found at ${config.paths.mission.path}`);
-    return { outcome: "nop", details: "No mission file found" };
-  }
-
-  if (existsSync("MISSION_COMPLETE.md") && config.supervisor !== "maintenance") {
-    logger.info("Mission complete — skipping transformation");
-    return { outcome: "nop", details: "Mission already complete" };
-  }
-
-  const features = scanDirectory(config.paths.features.path, ".md", { fileLimit: t.featuresScan || 10 }, logger);
-  const sourceFiles = scanDirectory(config.paths.source.path, [".js", ".ts"], {
-    fileLimit: t.sourceScan || 10,
-    contentLimit: t.sourceContent || 5000,
-    recursive: true, sortByMtime: true, clean: true, outline: true,
-  }, logger);
-  const webFiles = scanDirectory(config.paths.web?.path || "src/web/", [".html", ".css", ".js"], {
-    fileLimit: t.sourceScan || 10,
-    contentLimit: t.sourceContent || 5000,
-    recursive: true, sortByMtime: true, clean: true,
-  }, logger);
-
-  // GitHub issues (optional)
-  let openIssues = [];
-  let rawIssuesCount = 0;
-  if (octokit && repo) {
-    const { data: rawIssues } = await octokit.rest.issues.listForRepo({ ...repo, state: "open", per_page: t.issuesScan || 20 });
-    rawIssuesCount = rawIssues.length;
-    openIssues = filterIssues(rawIssues, { staleDays: t.staleDays || 30 });
-  }
-
-  let targetIssue = null;
-  if (issueNumber && octokit && repo) {
-    try {
-      const { data: issue } = await octokit.rest.issues.get({ ...repo, issue_number: Number(issueNumber) });
-      targetIssue = issue;
-    } catch (err) {
-      logger.warning(`Could not fetch target issue #${issueNumber}: ${err.message}`);
-    }
-  }
-
-  const agentInstructions = instructions || "Transform the repository toward its mission by identifying the next best action.";
-
-  const prompt = [
-    "## Instructions", agentInstructions, "",
-    ...(targetIssue ? [
-      `## Target Issue #${targetIssue.number}: ${targetIssue.title}`,
-      targetIssue.body || "(no description)",
-      `Labels: ${targetIssue.labels.map((l) => l.name).join(", ") || "none"}`,
-      "", "**Focus your transformation on resolving this specific issue.**", "",
-    ] : []),
-    "## Mission", mission, "",
-    `## Current Features (${features.length})`,
-    ...features.map((f) => `### ${f.name}\n${extractFeatureSummary(f.content, f.name)}`), "",
-    `## Current Source Files (${sourceFiles.length})`,
-    ...sourceFiles.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``), "",
-    ...(webFiles.length > 0 ? [
-      `## Website Files (${webFiles.length})`,
-      ...webFiles.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``), "",
-    ] : []),
-    ...(openIssues.length > 0 ? [
-      `## Open Issues (${openIssues.length})`,
-      ...openIssues.slice(0, t.issuesScan || 20).map((i) => summariseIssue(i, t.issueBodyLimit || 500)), "",
-    ] : []),
-    "## Output Artifacts",
-    `Save output artifacts to \`${config.paths.examples?.path || "examples/"}\`.`, "",
-    "## Your Task",
-    "Analyze the mission, features, source code, and open issues.",
-    "Determine the single most impactful next step to transform this repository.", "Then implement that step.", "",
-    "## When NOT to make changes",
-    "If the existing code already satisfies all requirements:", "- Do NOT make cosmetic changes", "- Instead, report that the mission is satisfied", "",
-    formatPathsSection(writablePaths, config.readOnlyPaths, config), "",
-    "## Constraints", `- Run \`${testCommand}\` to validate your changes`,
-  ].join("\n");
-
-  logger.info(`Transform prompt length: ${prompt.length} chars`);
-
-  const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
-    model,
-    systemMessage: "You are an autonomous code transformation agent. Your goal is to advance the repository toward its mission by making the most impactful change possible in a single step." + NARRATIVE_INSTRUCTION,
-    prompt, writablePaths, tuning: t, logger,
-  });
-
-  const promptBudget = [
-    { section: "mission", size: mission.length, files: "1", notes: "full" },
-    { section: "features", size: features.reduce((s, f) => s + f.content.length, 0), files: `${features.length}`, notes: "" },
-    { section: "source", size: sourceFiles.reduce((s, f) => s + f.content.length, 0), files: `${sourceFiles.length}`, notes: "" },
-    { section: "issues", size: openIssues.length * 80, files: `${openIssues.length}`, notes: `${rawIssuesCount - openIssues.length} filtered` },
-  ];
-
-  return {
-    outcome: "transformed", tokensUsed, inputTokens, outputTokens, cost, model,
-    details: resultContent.substring(0, 500),
-    narrative: extractNarrative(resultContent, "Transformation step completed."),
-    promptBudget,
-  };
-}