@xn-intenton-z2a/agentic-lib 7.1.69 → 7.1.71

package/.github/workflows/agentic-lib-init.yml

@@ -13,8 +13,6 @@ name: agentic-lib-init
 run-name: "agentic-lib-init [${{ github.ref_name }}]"
 
 on:
-  #@dist schedule:
-  #@dist   - cron: "0 5 * * *"
   workflow_call:
     inputs:
       mode:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xn-intenton-z2a/agentic-lib",
-  "version": "7.1.69",
+  "version": "7.1.71",
   "description": "Agentic-lib Agentic Coding Systems SDK powering automated GitHub workflows.",
   "type": "module",
   "scripts": {

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

@@ -9,7 +9,7 @@ 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 } from "fs";
+import { readFileSync, existsSync, readdirSync } from "fs";
 
 // Task implementations
 import { resolveIssue } from "./tasks/resolve-issue.js";
@@ -99,15 +99,63 @@ async function run() {
     if (result.action) core.setOutput("action", result.action);
     if (result.actionArg) core.setOutput("action-arg", result.actionArg);
 
-    // Compute limits status for enriched logging
+    const profileName = config.tuning?.profileName || "unknown";
+
+    // Transformation cost: 1 for code-changing tasks, 0 otherwise
+    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;
+
+    // Read cumulative transformation cost from the activity log
+    const intentionFilepath = config.intentionBot?.intentionFilepath;
+    let cumulativeCost = 0;
+    if (intentionFilepath && existsSync(intentionFilepath)) {
+      const logContent = readFileSync(intentionFilepath, "utf8");
+      const costMatches = logContent.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+      cumulativeCost = [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+    }
+    cumulativeCost += transformationCost;
+
+    // Count features and library docs on disk
+    const featuresPath = config.paths?.features?.path;
+    const featuresUsed = featuresPath && existsSync(featuresPath)
+      ? readdirSync(featuresPath).filter((f) => f.endsWith(".md")).length
+      : 0;
+    const libraryPath = config.paths?.library?.path;
+    const libraryUsed = libraryPath && existsSync(libraryPath)
+      ? readdirSync(libraryPath).filter((f) => f.endsWith(".md")).length
+      : 0;
+
+    // Count open automated issues (feature vs maintenance)
+    let featureIssueCount = 0;
+    let maintenanceIssueCount = 0;
+    try {
+      const { data: openAutoIssues } = await context.octokit.rest.issues.listForRepo({
+        ...context.repo,
+        state: "open",
+        labels: "automated",
+        per_page: 50,
+      });
+      for (const oi of openAutoIssues.filter((i) => !i.pull_request)) {
+        const lbls = oi.labels.map((l) => l.name);
+        if (lbls.includes("maintenance")) maintenanceIssueCount++;
+        else featureIssueCount++;
+      }
+    } catch (_) { /* API not available */ }
+
+    const budgetCap = config.transformationBudget || 0;
+    const featCap = config.paths?.features?.limit || 4;
+    const libCap = config.paths?.library?.limit || 32;
+
+    // Compute limits status with actual values
     const limitsStatus = [
-      { name: "transformation-budget", valueNum: 0, capacityNum: config.transformationBudget || 0, value: `0/${config.transformationBudget || 0}`, remaining: `${config.transformationBudget || 0}`, 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: "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: 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" },
+      { 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" },
     ];
 
     // Merge task-reported limits if available
@@ -119,15 +167,8 @@ async function run() {
     }
 
     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", "maintain-features", "maintain-library"];
-    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;
     if (intentionFilepath) {
       logActivity({
         filepath: intentionFilepath,

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

@@ -191,6 +191,50 @@ export async function discussions(context) {
     core.info("Mission complete signal written (MISSION_COMPLETE.md)");
   }
 
+  // Create issue when bot requests it
+  if (action === "create-issue" && actionArg) {
+    try {
+      const { data: issue } = await octokit.rest.issues.create({
+        ...context.repo,
+        title: actionArg,
+        labels: ["automated", "enhancement"],
+      });
+      core.info(`Created issue #${issue.number}: ${actionArg}`);
+    } catch (err) {
+      core.warning(`Failed to create issue: ${err.message}`);
+    }
+  }
+
+  // Request supervisor evaluation
+  if (action === "request-supervisor") {
+    try {
+      await octokit.rest.actions.createWorkflowDispatch({
+        ...context.repo,
+        workflow_id: "agentic-lib-workflow.yml",
+        ref: "main",
+        inputs: { message: actionArg || "Discussion bot referral" },
+      });
+      core.info(`Dispatched supervisor with message: ${actionArg}`);
+    } catch (err) {
+      core.warning(`Failed to dispatch supervisor: ${err.message}`);
+    }
+  }
+
+  // Stop automation
+  if (action === "stop") {
+    try {
+      await octokit.rest.actions.createWorkflowDispatch({
+        ...context.repo,
+        workflow_id: "agentic-lib-schedule.yml",
+        ref: "main",
+        inputs: { frequency: "off" },
+      });
+      core.info("Automation stopped via discussions bot");
+    } catch (err) {
+      core.warning(`Failed to stop automation: ${err.message}`);
+    }
+  }
+
   await postReply(octokit, discussion.nodeId, replyBody);
 
   const argSuffix = actionArg ? ` (${actionArg})` : "";

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

@@ -6,12 +6,17 @@
 // asks the Copilot SDK to choose multiple concurrent actions, then dispatches them.
 
 import * as core from "@actions/core";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import { runCopilotTask, readOptionalFile, scanDirectory, filterIssues } from "../copilot.js";
 
 async function gatherContext(octokit, repo, config, t) {
   const mission = readOptionalFile(config.paths.mission.path);
-  const recentActivity = readOptionalFile(config.intentionBot.intentionFilepath).split("\n").slice(-20).join("\n");
+  const intentionLogFull = readOptionalFile(config.intentionBot.intentionFilepath);
+  const recentActivity = intentionLogFull.split("\n").slice(-20).join("\n");
+
+  // Read cumulative transformation cost from the activity log
+  const costMatches = intentionLogFull.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+  const cumulativeTransformationCost = [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
 
   // Check mission-complete signal
   const missionComplete = existsSync("MISSION_COMPLETE.md");
@@ -20,6 +25,13 @@ async function gatherContext(octokit, repo, config, t) {
     missionCompleteInfo = readFileSync("MISSION_COMPLETE.md", "utf8").substring(0, 500);
   }
 
+  // Check mission-failed signal
+  const missionFailed = existsSync("MISSION_FAILED.md");
+  let missionFailedInfo = "";
+  if (missionFailed) {
+    missionFailedInfo = readFileSync("MISSION_FAILED.md", "utf8").substring(0, 500);
+  }
+
   // Check transformation budget
   const transformationBudget = config.transformationBudget || 0;
 
@@ -55,6 +67,36 @@ async function gatherContext(octokit, repo, config, t) {
     return `#${i.number}: ${i.title} [${labels || "no labels"}] (${age}d old)`;
   });
 
+  // Fetch recently-closed issues for mission-complete detection and dedup
+  let recentlyClosedSummary = [];
+  try {
+    const { data: closedIssuesRaw } = await octokit.rest.issues.listForRepo({
+      ...repo,
+      state: "closed",
+      per_page: 5,
+      sort: "updated",
+      direction: "desc",
+    });
+    for (const ci of closedIssuesRaw.filter((i) => !i.pull_request)) {
+      let closeReason = "closed";
+      try {
+        const { data: comments } = await octokit.rest.issues.listComments({
+          ...repo,
+          issue_number: ci.number,
+          per_page: 1,
+          sort: "created",
+          direction: "desc",
+        });
+        if (comments.length > 0 && comments[0].body?.includes("Automated Review Result")) {
+          closeReason = "closed by review as RESOLVED";
+        }
+      } catch (_) { /* ignore */ }
+      recentlyClosedSummary.push(`#${ci.number}: ${ci.title} — ${closeReason}`);
+    }
+  } catch (err) {
+    core.warning(`Could not fetch recently closed issues: ${err.message}`);
+  }
+
   const { data: openPRs } = await octokit.rest.pulls.list({
     ...repo,
     state: "open",
@@ -98,7 +140,11 @@ async function gatherContext(octokit, repo, config, t) {
     activeDiscussionUrl,
     missionComplete,
     missionCompleteInfo,
+    missionFailed,
+    missionFailedInfo,
     transformationBudget,
+    cumulativeTransformationCost,
+    recentlyClosedSummary,
   };
 }
 
@@ -114,6 +160,9 @@ function buildPrompt(ctx, agentInstructions) {
     `### 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",
     "",
@@ -150,8 +199,17 @@ function buildPrompt(ctx, agentInstructions) {
           "",
         ]
       : []),
+    ...(ctx.missionFailed
+      ? [
+          `### Mission Status: FAILED`,
+          ctx.missionFailedInfo,
+          "The mission has been declared failed. The schedule should be set to off.",
+          "You may still: review/close issues, respond to discussions.",
+          "",
+        ]
+      : []),
     ...(ctx.transformationBudget > 0
-      ? [`### Transformation Budget: ${ctx.transformationBudget} cycles per run`, ""]
+      ? [`### Transformation Budget: ${ctx.cumulativeTransformationCost}/${ctx.transformationBudget} used (${Math.max(0, ctx.transformationBudget - ctx.cumulativeTransformationCost)} remaining)`, ""]
       : []),
     `### Issue Limits`,
     `Feature development WIP limit: ${ctx.featureIssuesWipLimit}`,
@@ -176,6 +234,10 @@ function buildPrompt(ctx, agentInstructions) {
     "### Communication",
     "- `respond:discussions | message: <text> | discussion-url: <url>` — Reply via discussions bot",
     "",
+    "### Mission Lifecycle",
+    "- `mission-complete | reason: <text>` — Declare mission accomplished. Writes MISSION_COMPLETE.md and sets schedule to off. Use when: all acceptance criteria in MISSION.md are satisfied, tests pass, and recently-closed issues confirm resolution.",
+    "- `mission-failed | reason: <text>` — Declare mission failed. Writes MISSION_FAILED.md and sets schedule to off. Use when: transformation budget is exhausted with no progress, pipeline is stuck in a loop, or the mission is unachievable.",
+    "",
     "### Schedule Control",
     "- `set-schedule:<frequency>` — Change supervisor schedule (off, weekly, daily, hourly, continuous). Use `set-schedule:weekly` when mission is substantially complete, `set-schedule:continuous` to ramp up.",
     "",
@@ -253,6 +315,31 @@ async function executeDispatch(octokit, repo, actionName, params) {
 async function executeCreateIssue(octokit, repo, params) {
   const title = params.title || "Untitled issue";
   const labels = params.labels ? params.labels.split(",").map((l) => l.trim()) : ["automated"];
+
+  // Dedup guard: skip if a similarly-titled issue was closed in the last hour
+  try {
+    const { data: recent } = await octokit.rest.issues.listForRepo({
+      ...repo,
+      state: "closed",
+      sort: "updated",
+      direction: "desc",
+      per_page: 5,
+    });
+    const titlePrefix = title.toLowerCase().substring(0, 30);
+    const duplicate = recent.find(
+      (i) =>
+        !i.pull_request &&
+        i.title.toLowerCase().includes(titlePrefix) &&
+        Date.now() - new Date(i.closed_at).getTime() < 3600000,
+    );
+    if (duplicate) {
+      core.info(`Skipping duplicate issue (similar to recently closed #${duplicate.number})`);
+      return `skipped:duplicate-of-#${duplicate.number}`;
+    }
+  } catch (err) {
+    core.warning(`Dedup check failed: ${err.message}`);
+  }
+
   core.info(`Creating issue: ${title}`);
   const { data: issue } = await octokit.rest.issues.create({ ...repo, title, labels });
   return `created-issue:#${issue.number}`;
@@ -297,11 +384,65 @@ async function executeRespondDiscussions(octokit, repo, params) {
   return "skipped:respond-no-message";
 }
 
+async function executeMissionComplete(octokit, repo, params) {
+  const reason = params.reason || "All acceptance criteria satisfied";
+  const signal = [
+    "# Mission Complete",
+    "",
+    `- **Timestamp:** ${new Date().toISOString()}`,
+    `- **Detected by:** supervisor`,
+    `- **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);
+  core.info(`Mission complete signal written: ${reason}`);
+  try {
+    await octokit.rest.actions.createWorkflowDispatch({
+      ...repo,
+      workflow_id: "agentic-lib-schedule.yml",
+      ref: "main",
+      inputs: { frequency: "off" },
+    });
+  } catch (err) {
+    core.warning(`Could not set schedule to off: ${err.message}`);
+  }
+  return `mission-complete:${reason.substring(0, 100)}`;
+}
+
+async function executeMissionFailed(octokit, repo, params) {
+  const reason = params.reason || "Mission could not be completed";
+  const signal = [
+    "# Mission Failed",
+    "",
+    `- **Timestamp:** ${new Date().toISOString()}`,
+    `- **Detected by:** supervisor`,
+    `- **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);
+  core.info(`Mission failed signal written: ${reason}`);
+  try {
+    await octokit.rest.actions.createWorkflowDispatch({
+      ...repo,
+      workflow_id: "agentic-lib-schedule.yml",
+      ref: "main",
+      inputs: { frequency: "off" },
+    });
+  } catch (err) {
+    core.warning(`Could not set schedule to off: ${err.message}`);
+  }
+  return `mission-failed:${reason.substring(0, 100)}`;
+}
+
 const ACTION_HANDLERS = {
   "github:create-issue": executeCreateIssue,
   "github:label-issue": executeLabelIssue,
   "github:close-issue": executeCloseIssue,
   "respond:discussions": executeRespondDiscussions,
+  "mission-complete": executeMissionComplete,
+  "mission-failed": executeMissionFailed,
 };
 
 async function executeSetSchedule(octokit, repo, frequency) {
@@ -370,6 +511,17 @@ export async function supervise(context) {
     }
   }
 
+  // Build changes list from executed actions
+  const changes = results
+    .filter((r) => r.startsWith("created-issue:") || r.startsWith("mission-complete:") || r.startsWith("mission-failed:"))
+    .map((r) => {
+      if (r.startsWith("created-issue:")) return { action: "created-issue", file: r.replace("created-issue:", ""), sizeInfo: "" };
+      if (r.startsWith("mission-complete:")) return { action: "mission-complete", file: "MISSION_COMPLETE.md", sizeInfo: r.replace("mission-complete:", "") };
+      if (r.startsWith("mission-failed:")) return { action: "mission-failed", file: "MISSION_FAILED.md", sizeInfo: r.replace("mission-failed:", "") };
+      return null;
+    })
+    .filter(Boolean);
+
   return {
     outcome: actions.length === 0 ? "nop" : `supervised:${actions.length}-actions`,
     tokensUsed,
@@ -378,5 +530,7 @@ export async function supervise(context) {
     cost,
     model,
     details: `Actions: ${results.join(", ")}\nReasoning: ${reasoning.substring(0, 300)}`,
+    narrative: reasoning.substring(0, 500),
+    changes,
   };
 }

package/src/agents/agent-review-issue.md

@@ -1,11 +1,14 @@
 Does the combination source file, test file, website files, README file and dependencies file resolve the following issue? Check that the solution satisfies the issue's acceptance criteria and moves the mission toward complete.
 
-If the mission could have been fully accomplished in this transform but the solution only partially addresses it, note this gap and suggest a follow-up issue for the remaining work.
+An issue is NOT resolved unless ALL of the following are true:
+1. The implementation exists and matches what the issue asks for
+2. Tests exist that specifically test the implemented functionality (seed-only identity tests do NOT count)
+3. Tests match the acceptance criteria in MISSION.md — the mission is the source of truth
+4. Tests and implementation are consistent — test expectations must match what the code actually returns (casing, types, formats)
+
+If any of these are missing, the issue is NOT resolved — keep it open or create a follow-up issue for the gap. Do not close an issue just because implementation code exists without matching tests.
 
-When reviewing, check that:
-- Tests and implementation are consistent — test expectations must match what the code actually returns (casing, types, formats)
-- Tests match the acceptance criteria in MISSION.md — the mission is the source of truth
-- If tests expect different values than the code produces, create an issue to fix the mismatch
+If the mission could have been fully accomplished in this transform but the solution only partially addresses it, note this gap and suggest a follow-up issue for the remaining work.
 
 Note: The repository has a website in `src/web/` that uses the JS library. When reviewing, check that website files are updated alongside library changes.
 

package/src/agents/agent-supervisor.md

@@ -27,6 +27,8 @@ You are the supervisor of an autonomous coding repository. Your job is to advanc
 - **github:close-issue** — When an issue is clearly resolved or no longer relevant.
 - **respond:discussions** — When replying to a user request that came through the discussions bot. Include the discussion URL and a clear message.
 - **set-schedule:\<frequency\>** — Change the workflow schedule. Use `weekly` when mission is substantially achieved, `continuous` to ramp up for active development.
+- **mission-complete** — When all MISSION.md acceptance criteria are verified as satisfied. Review the Recently Closed Issues — if the last 2+ issues were closed by review as RESOLVED, 0 open issues remain, and the acceptance criteria in MISSION.md match the implemented code, declare mission complete. This writes MISSION_COMPLETE.md and sets the schedule to off. Always include a reason summarising what was achieved.
+- **mission-failed** — When the mission cannot be completed. Use when: transformation budget is exhausted with acceptance criteria still unmet, the pipeline is stuck in a create-close loop with no code changes, or 3+ consecutive transforms failed to produce working code. This writes MISSION_FAILED.md and sets the schedule to off. Always include a reason explaining what went wrong.
 - **nop** — When everything is running optimally: transform is active, issues are flowing, no failures.
 
 ## Stale Issue Detection
@@ -42,15 +44,16 @@ Include the website URL in the announcement — the site is at `https://<owner>.
 
 ### Mission Accomplished (bounded missions)
 When ALL of the following conditions are met, the mission is accomplished:
-1. All open issues are closed
+1. All open issues are closed (check Recently Closed Issues — if the last 2+ were closed by review as RESOLVED, this is strong evidence)
 2. Tests pass (CI gates commits, so this is usually the case)
-3. The MISSION.md acceptance criteria are all satisfied
-4. Evidence artifacts exist under `docs/` (example outputs, test results, or walkthroughs)
+3. The MISSION.md acceptance criteria are all satisfied (verify each criterion against the Recently Closed Issues and Recent Activity)
+4. Do not create an issue if a similar issue was recently closed as resolved — check the Recently Closed Issues section
 
-When all conditions are met:
-1. `dispatch:agentic-lib-bot` — announce mission accomplished in the discussions thread. Include the website URL (`https://<owner>.github.io/<repo>/`) where users can see the finished product.
-2. `set-schedule:off` — stop the workflow. The mission is done.
-3. Log `mission-accomplished` in the activity log.
+When all conditions are met, use the `mission-complete` action:
+1. `mission-complete | reason: <summary of what was achieved>` — this writes MISSION_COMPLETE.md and sets the schedule to off
+2. `dispatch:agentic-lib-bot` — announce mission accomplished in the discussions thread. Include the website URL (`https://<owner>.github.io/<repo>/`) where users can see the finished product.
+
+Do NOT create another issue when the mission is already accomplished. If the Recently Closed Issues show 2+ issues closed by review as RESOLVED and 0 open issues remain, the mission is done.
 
 ### Ongoing Missions
 If MISSION.md explicitly says "do not set schedule to off" or "ongoing mission", the mission never completes.
@@ -64,14 +67,33 @@ When the transform agent has implemented all major features but minor polish rem
 2. `set-schedule:weekly` — reduce to weekly maintenance check-ins
 3. Check that `docs/` contains evidence of the library working before declaring done
 
+### Mission Failed
+When the mission cannot be completed, use the `mission-failed` action. Indicators of failure:
+1. **Budget exhausted** — Transformation Budget shows usage at or near capacity with acceptance criteria still unmet
+2. **Pipeline stuck** — 3+ consecutive supervisor cycles created issues that were immediately closed by review as RESOLVED, but the acceptance criteria are NOT actually met (false positives in review)
+3. **No progress** — the last 3+ transforms produced no code changes (all nop outcomes) and acceptance criteria remain unmet
+4. **Repeated failures** — transforms keep producing code that fails tests, and fix-code cannot resolve the failures
+5. **Consuming budget without results** — transformation budget is being spent but the codebase is not converging toward the acceptance criteria
+
+When declaring mission failed:
+1. `mission-failed | reason: <what went wrong and what was achieved>` — this writes MISSION_FAILED.md and sets the schedule to off
+2. `dispatch:agentic-lib-bot` — announce the failure in the discussions thread with details of what was accomplished and what remains
+
 ## Prerequisites
 
 - The `set-schedule` action requires a `WORKFLOW_TOKEN` secret (classic PAT with `workflow` scope) to push workflow file changes to main.
 
 ## Stability Detection
 
-Check the Recent Activity log for patterns that indicate the mission is done:
-- If the last 2+ workflow runs produced no transform commits (only maintain-only or nop outcomes), AND all open issues are closed, the mission is likely accomplished. Follow the "Mission Accomplished" protocol above.
+Check the Recent Activity log and Recently Closed Issues for patterns:
+
+**Mission complete signals:**
+- If the last 2+ issues were closed by review as RESOLVED, AND 0 open issues remain, the mission is likely accomplished. Verify against MISSION.md acceptance criteria, then use `mission-complete`.
+- If the last 2+ workflow runs produced no transform commits (only maintain-only or nop outcomes), AND all open issues are closed, follow the "Mission Accomplished" protocol.
+
+**Mission failed signals:**
+- If the Transformation Budget shows usage near capacity (e.g. 28/32) and acceptance criteria are still unmet, the mission is failing. Use `mission-failed`.
+- If the last 3+ cycles show the pattern: create issue → review closes as resolved → no transform → create identical issue, the pipeline is stuck. Check if acceptance criteria are truly met (use `mission-complete`) or if review is wrong (create a more specific issue). If neither works, use `mission-failed`.
 - Look for `transform: nop` or `transform: transformed` patterns in the activity log to distinguish productive iterations from idle ones.
 
 ## Discussions Awareness

package/src/seeds/zero-package.json

@@ -16,7 +16,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xn-intenton-z2a/agentic-lib": "^7.1.69"
+    "@xn-intenton-z2a/agentic-lib": "^7.1.71"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",