@xn-intenton-z2a/agentic-lib 7.1.60 → 7.1.62

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

@@ -5,11 +5,154 @@
 // Extracts repeated patterns from the 8 task handlers into reusable functions.
 
 import { CopilotClient, approveAll } from "@github/copilot-sdk";
-import { readFileSync, readdirSync, existsSync } from "fs";
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
 import { join } from "path";
 import { createAgentTools } from "./tools.js";
 import * as core from "@actions/core";
 
+// Models known to support the reasoningEffort SessionConfig parameter.
+// Updated from Copilot SDK ModelInfo.supportedReasoningEfforts (v0.1.30).
+// When in doubt, omit reasoning-effort — the SDK uses its default.
+const MODELS_SUPPORTING_REASONING_EFFORT = new Set(["gpt-5-mini", "o4-mini"]);
+
+/**
+ * Strip noise from source code that has zero information value.
+ * Removes license headers, collapses blank lines, strips linter directives.
+ *
+ * @param {string} raw - Raw source code
+ * @returns {string} Cleaned source code
+ */
+export function cleanSource(raw) {
+  let cleaned = raw;
+  cleaned = cleaned.replace(/^\/\/\s*SPDX-License-Identifier:.*\n/gm, "");
+  cleaned = cleaned.replace(/^\/\/\s*Copyright.*\n/gm, "");
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+  cleaned = cleaned.replace(/^\s*\/\/\s*eslint-disable.*\n/gm, "");
+  cleaned = cleaned.replace(/^\s*\/\*\s*eslint-disable[\s\S]*?\*\/\s*\n/gm, "");
+  return cleaned.trimStart();
+}
+
+/**
+ * Generate a structural outline of a source file using regex-based extraction.
+ * Captures imports, exports, function/class declarations with line numbers.
+ *
+ * @param {string} raw - Raw source code
+ * @param {string} filePath - File path for the header line
+ * @returns {string} Structural outline
+ */
+export function generateOutline(raw, filePath) {
+  const lines = raw.split("\n");
+  const sizeKB = (raw.length / 1024).toFixed(1);
+  const parts = [`// file: ${filePath} (${lines.length} lines, ${sizeKB}KB)`];
+
+  const importSources = [];
+  for (const l of lines) {
+    const m = l.match(/^import\s.*from\s+["']([^"']+)["']/);
+    if (m) importSources.push(m[1]);
+  }
+  if (importSources.length > 0) parts.push(`// imports: ${importSources.join(", ")}`);
+
+  const exportNames = [];
+  for (const l of lines) {
+    const m = l.match(/^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+(\w+)/);
+    if (m) exportNames.push(m[1]);
+  }
+  if (exportNames.length > 0) parts.push(`// exports: ${exportNames.join(", ")}`);
+
+  parts.push("//");
+
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    const funcMatch = l.match(/^(export\s+)?(async\s+)?function\s+(\w+)\s*\(/);
+    if (funcMatch) {
+      parts.push(`// function ${funcMatch[3]}() — line ${i + 1}`);
+      continue;
+    }
+    const classMatch = l.match(/^(export\s+)?(default\s+)?class\s+(\w+)/);
+    if (classMatch) {
+      parts.push(`// class ${classMatch[3]} — line ${i + 1}`);
+      continue;
+    }
+    const methodMatch = l.match(/^\s+(async\s+)?(\w+)\s*\([^)]*\)\s*\{/);
+    if (methodMatch && !["if", "for", "while", "switch", "catch", "try"].includes(methodMatch[2])) {
+      parts.push(`//   ${methodMatch[2]}() — line ${i + 1}`);
+    }
+  }
+
+  return parts.join("\n");
+}
+
+/**
+ * Filter issues by recency and label quality.
+ *
+ * @param {Array} issues - GitHub issue objects
+ * @param {Object} [options]
+ * @param {number} [options.staleDays=30] - Issues older than this with no activity are excluded
+ * @param {boolean} [options.excludeBotOnly=true] - Exclude issues with only bot labels
+ * @returns {Array} Filtered issues
+ */
+export function filterIssues(issues, options = {}) {
+  const { staleDays = 30, excludeBotOnly = true } = options;
+  const cutoff = Date.now() - staleDays * 86400000;
+
+  return issues.filter((issue) => {
+    const lastActivity = new Date(issue.updated_at || issue.created_at).getTime();
+    if (lastActivity < cutoff) return false;
+
+    if (excludeBotOnly) {
+      const labels = (issue.labels || []).map((l) => (typeof l === "string" ? l : l.name));
+      const botLabels = ["automated", "stale", "bot", "wontfix"];
+      if (labels.length > 0 && labels.every((l) => botLabels.includes(l))) return false;
+    }
+
+    return true;
+  });
+}
+
+/**
+ * Create a compact summary of an issue for inclusion in prompts.
+ *
+ * @param {Object} issue - GitHub issue object
+ * @param {number} [bodyLimit=500] - Max chars for issue body
+ * @returns {string} Compact issue summary
+ */
+export function summariseIssue(issue, bodyLimit = 500) {
+  const labels = (issue.labels || []).map((l) => (typeof l === "string" ? l : l.name)).join(", ") || "no labels";
+  const age = Math.floor((Date.now() - new Date(issue.created_at).getTime()) / 86400000);
+  const body = (issue.body || "").substring(0, bodyLimit).replace(/\n+/g, " ").trim();
+  return `#${issue.number}: ${issue.title} [${labels}] (${age}d old)${body ? `\n  ${body}` : ""}`;
+}
+
+/**
+ * Extract a structured summary from a feature markdown file.
+ *
+ * @param {string} content - Feature file content
+ * @param {string} fileName - Feature file name
+ * @returns {string} Structured feature summary
+ */
+export function extractFeatureSummary(content, fileName) {
+  const lines = content.split("\n");
+  const title = lines.find((l) => l.startsWith("#"))?.replace(/^#+\s*/, "") || fileName;
+  const checked = (content.match(/- \[x\]/gi) || []).length;
+  const unchecked = (content.match(/- \[ \]/g) || []).length;
+  const total = checked + unchecked;
+
+  const parts = [`Feature: ${title}`];
+  if (total > 0) {
+    parts.push(`Status: ${checked}/${total} items complete`);
+    const remaining = [];
+    for (const line of lines) {
+      if (/- \[ \]/.test(line)) {
+        remaining.push(line.replace(/^[\s-]*\[ \]\s*/, "").trim());
+      }
+    }
+    if (remaining.length > 0) {
+      parts.push(`Remaining: ${remaining.map((r) => `[ ] ${r}`).join(", ")}`);
+    }
+  }
+  return parts.join("\n");
+}
+
 /**
  * Build the CopilotClient options for authentication.
  *
@@ -38,6 +181,34 @@ export function buildClientOptions(githubToken) {
   return { env };
 }
 
+/**
+ * Log tuning parameter application with profile context.
+ *
+ * @param {string} param - Parameter name
+ * @param {*} value - Resolved value being applied
+ * @param {string} profileName - Profile the default came from
+ * @param {string} model - Model being used
+ * @param {Object} [clip] - Optional clipping info { available, requested }
+ */
+export function logTuningParam(param, value, profileName, model, clip) {
+  const clipInfo = clip
+    ? ` (requested=${clip.requested}, available=${clip.available}, excess=${clip.requested - clip.available})`
+    : "";
+  core.info(`[tuning] ${param}=${value} profile=${profileName} model=${model}${clipInfo}`);
+}
+
+/**
+ * Check if a model supports reasoningEffort.
+ * Uses the static allowlist; at runtime the SDK's models.list() could be used
+ * but that requires an authenticated client which isn't available at config time.
+ *
+ * @param {string} model - Model name
+ * @returns {boolean}
+ */
+export function supportsReasoningEffort(model) {
+  return MODELS_SUPPORTING_REASONING_EFFORT.has(model);
+}
+
 /**
  * Run a Copilot SDK session and return the response.
  * Handles the full lifecycle: create client → create session → send → stop.
@@ -49,11 +220,21 @@ export function buildClientOptions(githubToken) {
  * @param {string[]} options.writablePaths - Paths the agent may modify
  * @param {string} [options.githubToken] - Optional token; falls back to COPILOT_GITHUB_TOKEN env var.
  * @param {Object} [options.tuning] - Tuning config (reasoningEffort, infiniteSessions)
+ * @param {string} [options.profileName] - Profile name for logging
  * @returns {Promise<{content: string, tokensUsed: number}>}
  */
-export async function runCopilotTask({ model, systemMessage, prompt, writablePaths, githubToken, tuning }) {
+export async function runCopilotTask({
+  model,
+  systemMessage,
+  prompt,
+  writablePaths,
+  githubToken,
+  tuning,
+  profileName,
+}) {
+  const profile = profileName || "unknown";
   core.info(
-    `[copilot] Creating client (model=${model}, promptLen=${prompt.length}, writablePaths=${writablePaths.length}, tuning=${tuning?.reasoningEffort || "default"})`,
+    `[copilot] Creating client (model=${model}, promptLen=${prompt.length}, writablePaths=${writablePaths.length}, tuning=${tuning?.reasoningEffort || "default"}, profile=${profile})`,
   );
 
   const clientOptions = buildClientOptions(githubToken);
@@ -68,12 +249,32 @@ export async function runCopilotTask({ model, systemMessage, prompt, writablePat
       onPermissionRequest: approveAll,
       workingDirectory: process.cwd(),
     };
-    if (tuning?.reasoningEffort) {
-      sessionConfig.reasoningEffort = tuning.reasoningEffort;
+
+    // Only set reasoningEffort for models that support it
+    if (tuning?.reasoningEffort && tuning.reasoningEffort !== "none") {
+      if (supportsReasoningEffort(model)) {
+        sessionConfig.reasoningEffort = tuning.reasoningEffort;
+        logTuningParam("reasoningEffort", tuning.reasoningEffort, profile, model);
+      } else {
+        core.info(
+          `[copilot] Skipping reasoningEffort="${tuning.reasoningEffort}" — not supported by model "${model}". Only supported by: ${[...MODELS_SUPPORTING_REASONING_EFFORT].join(", ")}`,
+        );
+      }
     }
+
     if (tuning?.infiniteSessions === true) {
       sessionConfig.infiniteSessions = {};
+      logTuningParam("infiniteSessions", true, profile, model);
     }
+
+    // Log scan/context tuning params
+    if (tuning?.featuresScan) logTuningParam("featuresScan", tuning.featuresScan, profile, model);
+    if (tuning?.sourceScan) logTuningParam("sourceScan", tuning.sourceScan, profile, model);
+    if (tuning?.sourceContent) logTuningParam("sourceContent", tuning.sourceContent, profile, model);
+    if (tuning?.issuesScan) logTuningParam("issuesScan", tuning.issuesScan, profile, model);
+    if (tuning?.documentSummary) logTuningParam("documentSummary", tuning.documentSummary, profile, model);
+    if (tuning?.discussionComments) logTuningParam("discussionComments", tuning.discussionComments, profile, model);
+
     const session = await client.createSession(sessionConfig);
     core.info(`[copilot] Session created: ${session.sessionId}`);
 
@@ -105,7 +306,9 @@ export async function runCopilotTask({ model, systemMessage, prompt, writablePat
         totalInputTokens += input;
         totalOutputTokens += output;
         totalCost += cost;
-        core.info(`[copilot] event=${eventType}: model=${d.model} input=${input} output=${output} cacheRead=${cacheRead} cost=${cost}`);
+        core.info(
+          `[copilot] event=${eventType}: model=${d.model} input=${input} output=${output} cacheRead=${cacheRead} cost=${cost}`,
+        );
       } else if (eventType === "session.idle") {
         core.info(`[copilot] event=${eventType}`);
       } else if (eventType === "session.error") {
@@ -153,26 +356,66 @@ export function readOptionalFile(filePath, limit) {
  * @param {number} [options.fileLimit=10] - Max files to return
  * @param {number} [options.contentLimit] - Max chars per file content
  * @param {boolean} [options.recursive=false] - Scan recursively
+ * @param {boolean} [options.sortByMtime=false] - Sort files by modification time (most recent first)
+ * @param {boolean} [options.clean=false] - Strip source noise (license headers, blank lines, linter directives)
+ * @param {boolean} [options.outline=false] - Generate structural outline when content exceeds limit
  * @returns {Array<{name: string, content: string}>}
  */
 export function scanDirectory(dirPath, extensions, options = {}) {
-  const { fileLimit = 10, contentLimit, recursive = false } = options;
+  const { fileLimit = 10, contentLimit, recursive = false, sortByMtime = false, clean = false, outline = false } = options;
   const exts = Array.isArray(extensions) ? extensions : [extensions];
 
   if (!existsSync(dirPath)) return [];
 
-  return readdirSync(dirPath, recursive ? { recursive: true } : undefined)
-    .filter((f) => exts.some((ext) => f.endsWith(ext)))
-    .slice(0, fileLimit)
-    .map((f) => {
+  const allFiles = readdirSync(dirPath, recursive ? { recursive: true } : undefined).filter((f) =>
+    exts.some((ext) => String(f).endsWith(ext)),
+  );
+
+  if (sortByMtime) {
+    allFiles.sort((a, b) => {
       try {
-        const content = readFileSync(join(dirPath, f), "utf8");
-        return { name: f, content: contentLimit ? content.substring(0, contentLimit) : content };
-      } catch (err) {
-        core.debug(`[scanDirectory] ${join(dirPath, f)}: ${err.message}`);
-        return { name: f, content: "" };
+        return statSync(join(dirPath, String(b))).mtimeMs - statSync(join(dirPath, String(a))).mtimeMs;
+      } catch {
+        return 0;
       }
     });
+  }
+
+  const clipped = allFiles.slice(0, fileLimit);
+  if (allFiles.length > fileLimit) {
+    core.info(
+      `[scanDirectory] Clipped ${dirPath}: ${allFiles.length} files found, returning ${fileLimit} (excess=${allFiles.length - fileLimit})`,
+    );
+  }
+
+  return clipped.map((f) => {
+    const fileName = String(f);
+    try {
+      let raw = readFileSync(join(dirPath, fileName), "utf8");
+      if (clean) raw = cleanSource(raw);
+
+      let content;
+      if (outline && contentLimit && raw.length > contentLimit) {
+        const outlineText = generateOutline(raw, fileName);
+        const halfLimit = Math.floor(contentLimit / 2);
+        content = outlineText + "\n\n" + raw.substring(0, halfLimit);
+        core.info(
+          `[scanDirectory] Outlined ${fileName}: ${raw.length} chars → outline + ${halfLimit} chars`,
+        );
+      } else {
+        content = contentLimit ? raw.substring(0, contentLimit) : raw;
+        if (contentLimit && raw.length > contentLimit) {
+          core.info(
+            `[scanDirectory] Clipped ${fileName}: ${raw.length} chars, returning ${contentLimit} (excess=${raw.length - contentLimit})`,
+          );
+        }
+      }
+      return { name: fileName, content };
+    } catch (err) {
+      core.debug(`[scanDirectory] ${join(dirPath, fileName)}: ${err.message}`);
+      return { name: fileName, content: "" };
+    }
+  });
 }
 
 /**

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

@@ -8,7 +8,7 @@
 import * as core from "@actions/core";
 import * as github from "@actions/github";
 import { loadConfig, getWritablePaths } from "./config-loader.js";
-import { logActivity } from "./logging.js";
+import { logActivity, generateClosingNotes } from "./logging.js";
 import { readFileSync } from "fs";
 
 // Task implementations
@@ -43,7 +43,7 @@ async function run() {
     const issueNumber = core.getInput("issue-number");
     const prNumber = core.getInput("pr-number");
     const writablePathsOverride = core.getInput("writable-paths");
-    const testCommand = core.getInput("test-command");
+    const testCommandInput = core.getInput("test-command");
     const discussionUrl = core.getInput("discussion-url");
     const model = core.getInput("model");
 
@@ -52,6 +52,7 @@ async function run() {
     // Load config
     const config = loadConfig(configPath);
     const writablePaths = getWritablePaths(config, writablePathsOverride);
+    const testCommand = testCommandInput || config.testScript;
 
     // Load instructions if provided
     let instructions = "";
@@ -95,6 +96,35 @@ async function run() {
     if (result.prNumber) core.setOutput("pr-number", String(result.prNumber));
     if (result.tokensUsed) core.setOutput("tokens-used", String(result.tokensUsed));
     if (result.model) core.setOutput("model", result.model);
+    if (result.action) core.setOutput("action", result.action);
+    if (result.actionArg) core.setOutput("action-arg", result.actionArg);
+
+    // Compute limits status for enriched logging
+    const limitsStatus = [
+      { name: "transformation-budget", valueNum: 0, capacityNum: config.transformationBudget || 0, value: `0/${config.transformationBudget || 0}`, remaining: `${config.transformationBudget || 0} remaining`, status: "" },
+      { name: "max-feature-issues", valueNum: 0, capacityNum: config.featureDevelopmentIssuesWipLimit, value: `?/${config.featureDevelopmentIssuesWipLimit}`, remaining: "?", status: "" },
+      { name: "max-maintenance-issues", valueNum: 0, capacityNum: config.maintenanceIssuesWipLimit, value: `?/${config.maintenanceIssuesWipLimit}`, remaining: "?", 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: 0, capacityNum: config.paths?.features?.limit || 4, value: `?/${config.paths?.features?.limit || 4}`, remaining: "?", status: ["maintain-features", "transform"].includes(task) ? "" : "n/a" },
+      { name: "library", valueNum: 0, capacityNum: config.paths?.library?.limit || 32, value: `?/${config.paths?.library?.limit || 32}`, remaining: "?", status: task === "maintain-library" ? "" : "n/a" },
+    ];
+
+    // Merge task-reported limits if available
+    if (result.limitsStatus) {
+      for (const reported of result.limitsStatus) {
+        const existing = limitsStatus.find((ls) => ls.name === reported.name);
+        if (existing) Object.assign(existing, reported);
+      }
+    }
+
+    const closingNotes = result.closingNotes || generateClosingNotes(limitsStatus);
+    const profileName = config.tuning?.profileName || "unknown";
+
+    // Transformation cost: 1 for code-changing tasks, 0 otherwise
+    const COST_TASKS = ["transform", "fix-code"];
+    const isNop = result.outcome === "nop" || result.outcome === "error";
+    const transformationCost = COST_TASKS.includes(task) && !isNop ? 1 : 0;
 
     // Log to intentïon.md (commit-if-changed excludes this on non-default branches)
     const intentionFilepath = config.intentionBot?.intentionFilepath;
@@ -114,6 +144,13 @@ async function run() {
         model: result.model || model,
         details: result.details,
         workflowUrl: `${process.env.GITHUB_SERVER_URL}/${github.context.repo.owner}/${github.context.repo.repo}/actions/runs/${github.context.runId}`,
+        profile: profileName,
+        changes: result.changes,
+        contextNotes: result.contextNotes,
+        limitsStatus,
+        promptBudget: result.promptBudget,
+        closingNotes,
+        transformationCost,
       });
     }
 

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

@@ -27,6 +27,13 @@ import * as core from "@actions/core";
  * @param {string} [options.model] - Model used
  * @param {string} [options.details] - Additional details
  * @param {string} [options.workflowUrl] - URL to the workflow run
+ * @param {string} [options.profile] - Active tuning profile name
+ * @param {Array} [options.changes] - List of file changes { action, file, sizeInfo }
+ * @param {string} [options.contextNotes] - English notes about task observations
+ * @param {Array} [options.limitsStatus] - Limit status entries { name, value, remaining, status }
+ * @param {Array} [options.promptBudget] - Prompt budget entries { section, size, files, notes }
+ * @param {string} [options.closingNotes] - Auto-generated limit concern notes
+ * @param {number} [options.transformationCost] - Transformation cost for this entry (0 or 1)
  */
 export function logActivity({
   filepath,
@@ -43,6 +50,13 @@ export function logActivity({
   model,
   details,
   workflowUrl,
+  profile,
+  changes,
+  contextNotes,
+  limitsStatus,
+  promptBudget,
+  closingNotes,
+  transformationCost,
 }) {
   const dir = dirname(filepath);
   if (!existsSync(dir)) {
@@ -56,6 +70,7 @@ export function logActivity({
   if (prNumber) parts.push(`**PR:** #${prNumber}`);
   if (commitUrl) parts.push(`**Commit:** [${commitUrl}](${commitUrl})`);
   if (model) parts.push(`**Model:** ${model}`);
+  if (profile) parts.push(`**Profile:** ${profile}`);
   if (tokensUsed) parts.push(`**Token Count:** ${tokensUsed} (in: ${inputTokens || 0}, out: ${outputTokens || 0})`);
   if (cost) parts.push(`**Model Invocations:** ${cost}`);
   if (durationMs) {
@@ -63,7 +78,38 @@ export function logActivity({
     const mins = (durationMs / 60000).toFixed(1);
     parts.push(`**Duration:** ${secs}s (~${mins} GitHub Actions min)`);
   }
+  if (transformationCost != null) parts.push(`**agentic-lib transformation cost:** ${transformationCost}`);
   if (workflowUrl) parts.push(`**Workflow:** [${workflowUrl}](${workflowUrl})`);
+  if (changes && changes.length > 0) {
+    parts.push("", "### What Changed");
+    for (const c of changes) {
+      parts.push(`- ${c.action}: \`${c.file}\`${c.sizeInfo ? ` (${c.sizeInfo})` : ""}`);
+    }
+  }
+  if (contextNotes) {
+    parts.push("", "### Context Notes");
+    parts.push(contextNotes);
+  }
+  if (limitsStatus && limitsStatus.length > 0) {
+    parts.push("", "### Limits Status");
+    parts.push("| Limit | Value | Capacity | Status |");
+    parts.push("|---|---|---|---|");
+    for (const ls of limitsStatus) {
+      parts.push(`| ${ls.name} | ${ls.value} | ${ls.remaining} remaining | ${ls.status || ""} |`);
+    }
+  }
+  if (promptBudget && promptBudget.length > 0) {
+    parts.push("", "### Prompt Budget");
+    parts.push("| Section | Size | Files | Notes |");
+    parts.push("|---|---|---|---|");
+    for (const pb of promptBudget) {
+      parts.push(`| ${pb.section} | ${pb.size} chars | ${pb.files || "—"} | ${pb.notes || ""} |`);
+    }
+  }
+  if (closingNotes) {
+    parts.push("", "### Closing Notes");
+    parts.push(closingNotes);
+  }
   if (details) {
     parts.push("");
     parts.push(details);
@@ -92,6 +138,35 @@ export function logActivity({
   }
 }
 
+/**
+ * Generate closing notes from limits status, flagging limits at or approaching capacity.
+ *
+ * @param {Array} limitsStatus - Array of { name, value, remaining, status, valueNum, capacityNum }
+ * @returns {string} Closing notes text
+ */
+export function generateClosingNotes(limitsStatus) {
+  if (!limitsStatus || limitsStatus.length === 0) return "";
+
+  const concerns = [];
+  let anyChecked = false;
+  for (const ls of limitsStatus) {
+    if (ls.status === "n/a") continue;
+    const used = ls.valueNum || 0;
+    const capacity = ls.capacityNum || 0;
+    if (capacity === 0) continue;
+    anyChecked = true;
+    const pct = Math.round((used / capacity) * 100);
+    if (pct >= 100) {
+      concerns.push(`${ls.name} at capacity (${ls.value}) — actions will be blocked.`);
+    } else if (pct >= 80) {
+      concerns.push(`${ls.name} approaching capacity (${ls.value}).`);
+    }
+  }
+
+  if (!anyChecked) return "";
+  return concerns.length > 0 ? concerns.join("\n") : "All limits within normal range.";
+}
+
 /**
  * Log a safety check outcome to the GitHub Actions log.
  *

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

@@ -6,7 +6,7 @@
 // and provides status updates. Uses the Copilot SDK for natural conversation.
 
 import * as core from "@actions/core";
-import { existsSync } from "fs";
+import { existsSync, writeFileSync } from "fs";
 import { runCopilotTask, readOptionalFile, scanDirectory } from "../copilot.js";
 
 const BOT_LOGINS = ["github-actions[bot]", "github-actions"];
@@ -175,6 +175,22 @@ export async function discussions(context) {
   const replyBody = content.replace(/\[ACTION:\S+?\].+/, "").trim();
 
   core.info(`Discussion bot action: ${action}, arg: ${actionArg}`);
+
+  // Write MISSION_COMPLETE.md signal when bot declares mission complete
+  if (action === "mission-complete") {
+    const signal = [
+      "# Mission Complete",
+      "",
+      `- **Timestamp:** ${new Date().toISOString()}`,
+      `- **Detected by:** discussions`,
+      `- **Reason:** ${actionArg || "Declared via discussion bot"}`,
+      "",
+      "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);
+    core.info("Mission complete signal written (MISSION_COMPLETE.md)");
+  }
+
   await postReply(octokit, discussion.nodeId, replyBody);
 
   const argSuffix = actionArg ? ` (${actionArg})` : "";

package/src/actions/agentic-step/tasks/maintain-features.js

@@ -5,7 +5,9 @@
 // Reviews existing features, creates new ones from mission/library analysis,
 // prunes completed/irrelevant features, and ensures quality.
 
-import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection } from "../copilot.js";
+import { existsSync } from "fs";
+import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection, extractFeatureSummary } from "../copilot.js";
+import { checkWipLimit } from "../safety.js";
 
 /**
  * Maintain the feature set — create, update, or prune feature files.
@@ -17,10 +19,28 @@ export async function maintainFeatures(context) {
   const { config, instructions, writablePaths, model, octokit, repo } = context;
   const t = config.tuning || {};
 
+  // Check mission-complete signal
+  if (existsSync("MISSION_COMPLETE.md")) {
+    return { outcome: "nop", details: "Mission already complete (MISSION_COMPLETE.md signal)" };
+  }
+
+  // Check maintenance WIP limit
+  const wipCheck = await checkWipLimit(octokit, repo, "maintenance", config.maintenanceIssuesWipLimit);
+  if (!wipCheck.allowed) {
+    return { outcome: "wip-limit-reached", details: `Maintenance WIP limit reached (${wipCheck.count}/${config.maintenanceIssuesWipLimit})` };
+  }
+
   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 });
+
+  // Sort features: incomplete (has unchecked items) first, then by name
+  features.sort((a, b) => {
+    const aIncomplete = /- \[ \]/.test(a.content) ? 0 : 1;
+    const bIncomplete = /- \[ \]/.test(b.content) ? 0 : 1;
+    return aIncomplete - bIncomplete || a.name.localeCompare(b.name);
+  });
   const libraryDocs = scanDirectory(config.paths.library.path, ".md", {
     contentLimit: t.documentSummary || 1000,
   });

package/src/actions/agentic-step/tasks/maintain-library.js

@@ -6,6 +6,7 @@
 // that provides context for feature generation and issue resolution.
 
 import * as core from "@actions/core";
+import { existsSync } from "fs";
 import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection } from "../copilot.js";
 
 /**
@@ -18,6 +19,12 @@ export async function maintainLibrary(context) {
   const { config, instructions, writablePaths, model } = context;
   const t = config.tuning || {};
 
+  // Check mission-complete signal
+  if (existsSync("MISSION_COMPLETE.md")) {
+    core.info("Mission is complete — skipping library maintenance");
+    return { outcome: "nop", details: "Mission already complete (MISSION_COMPLETE.md signal)" };
+  }
+
   const sources = readOptionalFile(config.paths.librarySources.path);
   if (!sources.trim()) {
     core.info("No sources found. Returning nop.");

package/src/actions/agentic-step/tasks/review-issue.js

@@ -35,11 +35,16 @@ async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, ins
     contentLimit: t.sourceContent || 5000,
     fileLimit: t.sourceScan || 20,
     recursive: true,
+    sortByMtime: true,
+    clean: true,
+    outline: true,
   });
   const testFiles = scanDirectory(config.paths.tests.path, [".test.js", ".test.ts"], {
-    contentLimit: t.sourceContent || 5000,
+    contentLimit: t.testContent || t.sourceContent || 5000,
     fileLimit: t.sourceScan || 20,
     recursive: true,
+    sortByMtime: true,
+    clean: true,
   });
   const docsFiles = scanDirectory(config.paths.documentation?.path || "docs/", [".md"], {
     fileLimit: t.featuresScan || 10,