@xn-intenton-z2a/agentic-lib 7.1.70 → 7.1.72

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/bin/agentic-lib.js

@@ -856,10 +856,30 @@ function clearDirContents(dirPath, label) {
   }
 }
 
-function initReseed() {
+function initReseed(initTimestamp) {
   console.log("\n--- Reseed: Clear Features + Activity Log ---");
   removeFile(resolve(target, "intentïon.md"), "intentïon.md");
   removeFile(resolve(target, "MISSION_COMPLETE.md"), "MISSION_COMPLETE.md");
+  removeFile(resolve(target, "MISSION_FAILED.md"), "MISSION_FAILED.md");
+
+  // Write init epoch header to the activity log
+  const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf8"));
+  const mode = purge ? "purge" : "reseed";
+  const initHeader = [
+    `# intentïon activity log`,
+    "",
+    `**init ${mode}** at ${initTimestamp} (agentic-lib@${pkg.version})`,
+    `**mission:** ${mission}`,
+    "",
+    "---",
+    "",
+  ].join("\n");
+  if (!dryRun) {
+    writeFileSync(resolve(target, "intentïon.md"), initHeader);
+  }
+  console.log("  WRITE: intentïon.md (init epoch header)");
+  initChanges++;
+
   clearDirContents(resolve(target, "features"), "features");
 
   // Clear old features location if it exists
@@ -916,7 +936,7 @@ function clearAndRecreateDir(dirPath, label) {
   if (!dryRun) mkdirSync(fullPath, { recursive: true });
 }
 
-function initPurge(seedsDir, missionName) {
+function initPurge(seedsDir, missionName, initTimestamp) {
   console.log("\n--- Purge: Reset Source Files to Seed State ---");
 
   const { sourcePath, testsPath, examplesPath, webPath } = readTomlPaths();
@@ -980,10 +1000,46 @@ function initPurge(seedsDir, missionName) {
     }
     process.exit(1);
   }
+
+  // Write init metadata to agentic-lib.toml
+  const tomlTarget = resolve(target, "agentic-lib.toml");
+  if (existsSync(tomlTarget)) {
+    let toml = readFileSync(tomlTarget, "utf8");
+    const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf8"));
+    const initSection = [
+      "",
+      "[init]",
+      `timestamp = "${initTimestamp}"`,
+      `mode = "purge"`,
+      `mission = "${missionName}"`,
+      `version = "${pkg.version}"`,
+    ].join("\n");
+    // Replace existing [init] section or append
+    if (/^\[init\]/m.test(toml)) {
+      toml = toml.replace(/\n?\[init\][^\[]*/, initSection);
+    } else {
+      toml = toml.trimEnd() + "\n" + initSection + "\n";
+    }
+    if (!dryRun) {
+      writeFileSync(tomlTarget, toml);
+    }
+    console.log("  WRITE: [init] section in agentic-lib.toml");
+    initChanges++;
+  }
+}
+
+function ghExec(cmd, input) {
+  const opts = { cwd: target, encoding: "utf8", timeout: 30000, stdio: ["pipe", "pipe", "pipe"] };
+  if (input) opts.input = input;
+  return execSync(cmd, opts);
+}
+
+function ghGraphQL(query) {
+  return JSON.parse(ghExec("gh api graphql --input -", JSON.stringify({ query })));
 }
 
 function initPurgeGitHub() {
-  console.log("\n--- Purge: Close GitHub Issues + Lock Discussions ---");
+  console.log("\n--- Purge: Clean Slate (Issues, PRs, Runs, Branches, Labels, Discussions) ---");
 
   // Detect the GitHub repo from git remote
   let repoSlug = "";
@@ -993,7 +1049,6 @@ function initPurgeGitHub() {
       encoding: "utf8",
       timeout: 10000,
     }).trim();
-    // Parse owner/repo from git@github.com:owner/repo.git or https://github.com/owner/repo.git
     const match = remoteUrl.match(/github\.com[:/]([^/]+\/[^/.]+)/);
     if (match) repoSlug = match[1].replace(/\.git$/, "");
   } catch {
@@ -1005,7 +1060,6 @@ function initPurgeGitHub() {
     return;
   }
 
-  // Check gh CLI is available
   try {
     execSync("gh --version", { encoding: "utf8", timeout: 5000, stdio: "pipe" });
   } catch {
@@ -1013,29 +1067,205 @@ function initPurgeGitHub() {
     return;
   }
 
-  // Close all open issues
+  const [owner, repo] = repoSlug.split("/");
+
+  // ── A1: Close + lock ALL issues (open and closed) ──────────────────
+  console.log("\n  --- Issues: close open, lock all ---");
+  try {
+    // Close all open issues with not_planned reason
+    const openIssuesJson = ghExec(`gh api repos/${repoSlug}/issues?state=open&per_page=100`);
+    const openIssues = JSON.parse(openIssuesJson || "[]").filter((i) => !i.pull_request);
+    for (const issue of openIssues) {
+      console.log(`  CLOSE: issue #${issue.number} — ${issue.title}`);
+      if (!dryRun) {
+        try {
+          ghExec(
+            `gh api repos/${repoSlug}/issues/${issue.number} -X PATCH -f state=closed -f state_reason=not_planned`,
+          );
+          ghExec(
+            `gh api repos/${repoSlug}/issues/${issue.number}/comments -X POST -f body="Closed by init --purge (mission reset)"`,
+          );
+          initChanges++;
+        } catch (err) {
+          console.log(`  WARN: Failed to close issue #${issue.number}: ${err.message}`);
+        }
+      } else {
+        initChanges++;
+      }
+    }
+    if (openIssues.length === 0) console.log("  No open issues to close");
+
+    // Lock ALL issues (open and closed) to prevent bleed
+    const allIssuesJson = ghExec(`gh api repos/${repoSlug}/issues?state=all&per_page=100`);
+    const allIssues = JSON.parse(allIssuesJson || "[]").filter((i) => !i.pull_request && !i.locked);
+    for (const issue of allIssues) {
+      console.log(`  LOCK: issue #${issue.number} — ${issue.title}`);
+      if (!dryRun) {
+        try {
+          ghExec(
+            `gh api repos/${repoSlug}/issues/${issue.number}/lock -X PUT -f lock_reason=resolved`,
+          );
+          initChanges++;
+        } catch (err) {
+          console.log(`  WARN: Failed to lock issue #${issue.number}: ${err.message}`);
+        }
+      } else {
+        initChanges++;
+      }
+    }
+    if (allIssues.length === 0) console.log("  No unlocked issues to lock");
+  } catch (err) {
+    console.log(`  WARN: Issue cleanup failed: ${err.message}`);
+  }
+
+  // ── A2: Close all open PRs + delete branches ──────────────────────
+  console.log("\n  --- PRs: close all open ---");
+  try {
+    const prsJson = ghExec(`gh pr list --repo ${repoSlug} --state open --json number,title,headRefName --limit 100`);
+    const prs = JSON.parse(prsJson || "[]");
+    for (const pr of prs) {
+      console.log(`  CLOSE: PR #${pr.number} — ${pr.title} (${pr.headRefName})`);
+      if (!dryRun) {
+        try {
+          ghExec(`gh pr close ${pr.number} --repo ${repoSlug} --delete-branch`);
+          initChanges++;
+        } catch (err) {
+          console.log(`  WARN: Failed to close PR #${pr.number}: ${err.message}`);
+        }
+      } else {
+        initChanges++;
+      }
+    }
+    if (prs.length === 0) console.log("  No open PRs to close");
+  } catch (err) {
+    console.log(`  WARN: PR cleanup failed: ${err.message}`);
+  }
+
+  // ── A3: Delete old workflow runs ──────────────────────────────────
+  console.log("\n  --- Workflow runs: delete old ---");
   try {
-    const issuesJson = execSync(`gh issue list --repo ${repoSlug} --state open --json number,title --limit 100`, {
+    const runsJson = ghExec(`gh api repos/${repoSlug}/actions/runs?per_page=100`);
+    const runs = JSON.parse(runsJson || '{"workflow_runs":[]}').workflow_runs || [];
+    let deleted = 0;
+    for (const run of runs) {
+      // Skip currently running workflows (in_progress or queued)
+      if (run.status === "in_progress" || run.status === "queued") {
+        console.log(`  SKIP: run ${run.id} (${run.name}) — ${run.status}`);
+        continue;
+      }
+      if (!dryRun) {
+        try {
+          ghExec(`gh api repos/${repoSlug}/actions/runs/${run.id} -X DELETE`);
+          deleted++;
+        } catch (err) {
+          console.log(`  WARN: Failed to delete run ${run.id}: ${err.message}`);
+        }
+      } else {
+        deleted++;
+      }
+    }
+    console.log(`  ${deleted > 0 ? `DELETE: ${deleted} workflow run(s)` : "No workflow runs to delete"}`);
+    initChanges += deleted;
+  } catch (err) {
+    console.log(`  WARN: Workflow run cleanup failed: ${err.message}`);
+  }
+
+  // ── A4: Delete stale remote branches ──────────────────────────────
+  console.log("\n  --- Branches: delete stale remotes ---");
+  try {
+    const branchesJson = ghExec(`gh api repos/${repoSlug}/branches?per_page=100`);
+    const branches = JSON.parse(branchesJson || "[]");
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
       cwd: target,
       encoding: "utf8",
-      timeout: 30000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    const issues = JSON.parse(issuesJson || "[]");
-    if (issues.length === 0) {
-      console.log("  No open issues to close");
-    } else {
-      for (const issue of issues) {
-        console.log(`  CLOSE: issue #${issue.number} — ${issue.title}`);
+      timeout: 5000,
+    }).trim();
+    const keepBranches = new Set(["main", "master", "template", "gh-pages", currentBranch]);
+    let deletedBranches = 0;
+    for (const branch of branches) {
+      if (keepBranches.has(branch.name)) continue;
+      if (branch.protected) continue;
+      console.log(`  DELETE: branch ${branch.name}`);
+      if (!dryRun) {
+        try {
+          ghExec(`gh api repos/${repoSlug}/git/refs/heads/${branch.name} -X DELETE`);
+          deletedBranches++;
+        } catch (err) {
+          console.log(`  WARN: Failed to delete branch ${branch.name}: ${err.message}`);
+        }
+      } else {
+        deletedBranches++;
+      }
+    }
+    if (deletedBranches === 0) console.log("  No stale branches to delete");
+    initChanges += deletedBranches;
+  } catch (err) {
+    console.log(`  WARN: Branch cleanup failed: ${err.message}`);
+  }
+
+  // ── A5: Reset labels ──────────────────────────────────────────────
+  console.log("\n  --- Labels: reset to pipeline defaults ---");
+  const GITHUB_DEFAULT_LABELS = new Set([
+    "bug",
+    "documentation",
+    "duplicate",
+    "enhancement",
+    "good first issue",
+    "help wanted",
+    "invalid",
+    "question",
+    "wontfix",
+  ]);
+  const PIPELINE_LABELS = [
+    { name: "automated", color: "0e8a16", description: "Created by the autonomous pipeline" },
+    { name: "ready", color: "0075ca", description: "Issue is ready for transformation" },
+    { name: "in-progress", color: "e4e669", description: "Work in progress" },
+    { name: "merged", color: "6f42c1", description: "Associated PR has been merged" },
+    { name: "automerge", color: "1d76db", description: "PR should be auto-merged when checks pass" },
+  ];
+  try {
+    const labelsJson = ghExec(`gh api repos/${repoSlug}/labels?per_page=100`);
+    const labels = JSON.parse(labelsJson || "[]");
+    const pipelineNames = new Set(PIPELINE_LABELS.map((l) => l.name));
+    // Delete non-default, non-pipeline labels
+    for (const label of labels) {
+      if (GITHUB_DEFAULT_LABELS.has(label.name)) continue;
+      if (pipelineNames.has(label.name)) continue;
+      console.log(`  DELETE: label "${label.name}"`);
+      if (!dryRun) {
+        try {
+          ghExec(`gh api repos/${repoSlug}/labels/${encodeURIComponent(label.name)} -X DELETE`);
+          initChanges++;
+        } catch (err) {
+          console.log(`  WARN: Failed to delete label "${label.name}": ${err.message}`);
+        }
+      } else {
+        initChanges++;
+      }
+    }
+    // Ensure pipeline labels exist with correct config
+    const existingNames = new Set(labels.map((l) => l.name));
+    for (const pl of PIPELINE_LABELS) {
+      if (existingNames.has(pl.name)) {
+        // Update to ensure correct color/description
         if (!dryRun) {
           try {
-            execSync(
-              `gh issue close ${issue.number} --repo ${repoSlug} --comment "Closed by init --purge (mission reset)"`,
-              { cwd: target, encoding: "utf8", timeout: 15000, stdio: "pipe" },
+            ghExec(
+              `gh api repos/${repoSlug}/labels/${encodeURIComponent(pl.name)} -X PATCH -f color=${pl.color} -f description="${pl.description}"`,
+            );
+          } catch { /* ignore */ }
+        }
+        console.log(`  UPDATE: label "${pl.name}"`);
+      } else {
+        console.log(`  CREATE: label "${pl.name}"`);
+        if (!dryRun) {
+          try {
+            ghExec(
+              `gh api repos/${repoSlug}/labels -X POST -f name="${pl.name}" -f color=${pl.color} -f description="${pl.description}"`,
             );
             initChanges++;
           } catch (err) {
-            console.log(`  WARN: Failed to close issue #${issue.number}: ${err.message}`);
+            console.log(`  WARN: Failed to create label "${pl.name}": ${err.message}`);
           }
         } else {
           initChanges++;
@@ -1043,23 +1273,15 @@ function initPurgeGitHub() {
       }
     }
   } catch (err) {
-    console.log(`  WARN: Could not list issues: ${err.message}`);
+    console.log(`  WARN: Label cleanup failed: ${err.message}`);
   }
 
-  // Close open discussions
-  const [owner, repo] = repoSlug.split("/");
+  // ── Discussions: close all open, create fresh one ─────────────────
+  console.log("\n  --- Discussions: close open, create fresh ---");
   try {
-    const query = JSON.stringify({
-      query: `{ repository(owner:"${owner}", name:"${repo}") { discussions(first:50, states:OPEN) { nodes { id number title } } } }`,
-    });
-    const result = execSync(`gh api graphql --input -`, {
-      cwd: target,
-      encoding: "utf8",
-      timeout: 30000,
-      input: query,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    const parsed = JSON.parse(result);
+    const parsed = ghGraphQL(
+      `{ repository(owner:"${owner}", name:"${repo}") { discussions(first:50, states:OPEN) { nodes { id number title } } } }`,
+    );
     const discussions = parsed?.data?.repository?.discussions?.nodes || [];
     if (discussions.length === 0) {
       console.log("  No open discussions to close");
@@ -1068,16 +1290,7 @@ function initPurgeGitHub() {
         console.log(`  CLOSE: discussion #${disc.number} — ${disc.title}`);
         if (!dryRun) {
           try {
-            const mutation = JSON.stringify({
-              query: `mutation { closeDiscussion(input: { discussionId: "${disc.id}" }) { discussion { number } } }`,
-            });
-            execSync(`gh api graphql --input -`, {
-              cwd: target,
-              encoding: "utf8",
-              timeout: 15000,
-              input: mutation,
-              stdio: ["pipe", "pipe", "pipe"],
-            });
+            ghGraphQL(`mutation { closeDiscussion(input: { discussionId: "${disc.id}" }) { discussion { number } } }`);
             initChanges++;
           } catch {
             console.log(`  SKIP: Could not close discussion #${disc.number} (may need admin permissions)`);
@@ -1093,18 +1306,9 @@ function initPurgeGitHub() {
 
   // Create a new "Talk to the repository" discussion
   try {
-    // Get the repository node ID and "General" category ID
-    const repoQuery = JSON.stringify({
-      query: `{ repository(owner:"${owner}", name:"${repo}") { id discussionCategories(first:20) { nodes { id name } } } }`,
-    });
-    const repoResult = execSync(`gh api graphql --input -`, {
-      cwd: target,
-      encoding: "utf8",
-      timeout: 30000,
-      input: repoQuery,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    const repoParsed = JSON.parse(repoResult);
+    const repoParsed = ghGraphQL(
+      `{ repository(owner:"${owner}", name:"${repo}") { id discussionCategories(first:20) { nodes { id name } } } }`,
+    );
     const repoId = repoParsed?.data?.repository?.id;
     const categories = repoParsed?.data?.repository?.discussionCategories?.nodes || [];
     const generalCat = categories.find((c) => c.name === "General");
@@ -1113,17 +1317,9 @@ function initPurgeGitHub() {
     } else {
       console.log('  CREATE: discussion "Talk to the repository" in General category');
       if (!dryRun) {
-        const createMutation = JSON.stringify({
-          query: `mutation { createDiscussion(input: { repositoryId: "${repoId}", categoryId: "${generalCat.id}", title: "Talk to the repository", body: "This discussion is the main channel for interacting with the repository's autonomous agents.\\n\\nUse this thread to:\\n- Submit feature requests or ideas\\n- Ask questions about the project\\n- Chat with the discussions bot\\n\\n---\\n*Created by init --purge*" }) { discussion { number url } } }`,
-        });
-        const createResult = execSync(`gh api graphql --input -`, {
-          cwd: target,
-          encoding: "utf8",
-          timeout: 15000,
-          input: createMutation,
-          stdio: ["pipe", "pipe", "pipe"],
-        });
-        const createParsed = JSON.parse(createResult);
+        const createParsed = ghGraphQL(
+          `mutation { createDiscussion(input: { repositoryId: "${repoId}", categoryId: "${generalCat.id}", title: "Talk to the repository", body: "This discussion is the main channel for interacting with the repository's autonomous agents.\\n\\nUse this thread to:\\n- Submit feature requests or ideas\\n- Ask questions about the project\\n- Chat with the discussions bot\\n\\n---\\n*Created by init --purge*" }) { discussion { number url } } }`,
+        );
         const newDisc = createParsed?.data?.createDiscussion?.discussion;
         if (newDisc) {
           console.log(`  CREATED: discussion #${newDisc.number} — ${newDisc.url}`);
@@ -1137,7 +1333,7 @@ function initPurgeGitHub() {
     console.log(`  SKIP: Could not create discussion (${err.message})`);
   }
 
-  // Enable GitHub Pages (serve from docs/ on main branch)
+  // ── Enable GitHub Pages ───────────────────────────────────────────
   console.log("\n--- Enable GitHub Pages ---");
   try {
     if (!dryRun) {
@@ -1187,14 +1383,31 @@ function runInit() {
   console.log(`Mode:    ${dryRun ? "DRY RUN" : "LIVE"}`);
   console.log("");
 
+  // Capture existing init timestamp before any destructive operations (for idempotency).
+  // The TOML [init] section is the authoritative record. If it matches the current
+  // mode/mission/version, reuse its timestamp so that re-running init is a no-op.
+  const pkg = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf8"));
+  let initTimestamp = null;
+  const tomlPath = resolve(target, "agentic-lib.toml");
+  if (existsSync(tomlPath)) {
+    const tomlContent = readFileSync(tomlPath, "utf8");
+    const tm = tomlContent.match(/^\[init\]\s*\ntimestamp\s*=\s*"([^"]+)"\s*\nmode\s*=\s*"([^"]+)"\s*\nmission\s*=\s*"([^"]+)"\s*\nversion\s*=\s*"([^"]+)"/m);
+    const mode = purge ? "purge" : reseed ? "reseed" : null;
+    if (tm && mode && tm[2] === mode && tm[3] === mission && tm[4] === pkg.version) {
+      initTimestamp = tm[1];
+    }
+  }
+  // Use a single timestamp for the entire init run (for consistency across files)
+  if (!initTimestamp) initTimestamp = new Date().toISOString();
+
   initWorkflows();
   initActions(agenticDir);
   initDirContents("agents", resolve(agenticDir, "agents"), "Agents");
   initDirContents("seeds", resolve(agenticDir, "seeds"), "Seeds");
   initScripts(agenticDir);
   initConfig(seedsDir);
-  if (reseed) initReseed();
-  if (purge) initPurge(seedsDir, mission);
+  if (reseed) initReseed(initTimestamp);
+  if (purge) initPurge(seedsDir, mission, initTimestamp);
   if (purge) initPurgeGitHub();
 
   console.log(`\n${initChanges} change(s)${dryRun ? " (dry run)" : ""}`);

package/package.json

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

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

@@ -271,6 +271,7 @@ export function loadConfig(configPath) {
     intentionBot: {
       intentionFilepath: bot["log-file"] || "intentïon.md",
     },
+    init: toml.init || null,
     tdd: toml.tdd === true,
     writablePaths,
     readOnlyPaths,

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

@@ -53,7 +53,7 @@ async function fetchDiscussion(octokit, discussionUrl, commentsLimit = 10) {
   }
 }
 
-function buildPrompt(discussionUrl, discussion, context, t) {
+function buildPrompt(discussionUrl, discussion, context, t, repoContext) {
   const { config, instructions } = context;
   const { title, body, comments } = discussion;
 
@@ -99,6 +99,28 @@ function buildPrompt(discussionUrl, discussion, context, t) {
     `### Mission\n${mission}`,
     contributing ? `### Contributing\n${contributing}` : "",
     `### Current Features\n${featureNames.join(", ") || "none"}`,
+  );
+
+  // Add issue context
+  if (repoContext?.issuesSummary?.length > 0) {
+    parts.push(`### Open Issues (${repoContext.issuesSummary.length})`, repoContext.issuesSummary.join("\n"));
+  }
+
+  // Add actions-since-init context
+  if (repoContext?.actionsSinceInit?.length > 0) {
+    parts.push(
+      `### Actions Since Last Init${repoContext.initTimestamp ? ` (${repoContext.initTimestamp})` : ""}`,
+      ...repoContext.actionsSinceInit.map((a) => {
+        let line = `- ${a.name}: ${a.conclusion} (${a.created}) [${a.commitSha}] ${a.commitMessage}`;
+        if (a.prNumber) {
+          line += ` — PR #${a.prNumber}: +${a.additions}/-${a.deletions} in ${a.changedFiles} file(s)`;
+        }
+        return line;
+      }),
+    );
+  }
+
+  parts.push(
     recentActivity ? `### Recent Activity\n${recentActivity}` : "",
     config.configToml ? `### Configuration (agentic-lib.toml)\n\`\`\`toml\n${config.configToml}\n\`\`\`` : "",
     config.packageJson ? `### Dependencies (package.json)\n\`\`\`json\n${config.packageJson}\n\`\`\`` : "",
@@ -151,15 +173,72 @@ async function postReply(octokit, nodeId, replyBody) {
  * @returns {Promise<Object>} Result with outcome, action, tokensUsed, model
  */
 export async function discussions(context) {
-  const { octokit, model, discussionUrl } = context;
-  const t = context.config?.tuning || {};
+  const { octokit, model, discussionUrl, repo, config } = context;
+  const t = config?.tuning || {};
 
   if (!discussionUrl) {
     throw new Error("discussions task requires discussion-url input");
   }
 
+  // Gather repo context: issues + actions since init
+  const repoContext = { issuesSummary: [], actionsSinceInit: [], initTimestamp: null };
+  if (octokit && repo) {
+    try {
+      const { data: openIssues } = await octokit.rest.issues.listForRepo({
+        ...repo, state: "open", per_page: 10, sort: "created", direction: "asc",
+      });
+      repoContext.issuesSummary = openIssues
+        .filter((i) => !i.pull_request)
+        .map((i) => {
+          const labels = i.labels.map((l) => l.name).join(", ");
+          return `#${i.number}: ${i.title} [${labels || "no labels"}]`;
+        });
+    } catch (err) {
+      core.warning(`Could not fetch issues for discussion context: ${err.message}`);
+    }
+
+    const initTimestamp = config?.init?.timestamp || null;
+    repoContext.initTimestamp = initTimestamp;
+    try {
+      const { data: runs } = await octokit.rest.actions.listWorkflowRunsForRepo({
+        ...repo, per_page: 20,
+      });
+      const initDate = initTimestamp ? new Date(initTimestamp) : null;
+      const relevantRuns = initDate
+        ? runs.workflow_runs.filter((r) => new Date(r.created_at) >= initDate)
+        : runs.workflow_runs.slice(0, 10);
+
+      for (const run of relevantRuns) {
+        const commit = run.head_commit;
+        const entry = {
+          name: run.name,
+          conclusion: run.conclusion || run.status,
+          created: run.created_at,
+          commitMessage: commit?.message?.split("\n")[0] || "",
+          commitSha: run.head_sha?.substring(0, 7) || "",
+        };
+        if (run.head_branch?.startsWith("agentic-lib-issue-")) {
+          try {
+            const { data: prs } = await octokit.rest.pulls.list({
+              ...repo, head: `${repo.owner}:${run.head_branch}`, state: "all", per_page: 1,
+            });
+            if (prs.length > 0) {
+              entry.prNumber = prs[0].number;
+              entry.additions = prs[0].additions;
+              entry.deletions = prs[0].deletions;
+              entry.changedFiles = prs[0].changed_files;
+            }
+          } catch { /* ignore */ }
+        }
+        repoContext.actionsSinceInit.push(entry);
+      }
+    } catch (err) {
+      core.warning(`Could not fetch workflow runs for discussion context: ${err.message}`);
+    }
+  }
+
   const discussion = await fetchDiscussion(octokit, discussionUrl, t.discussionComments || 10);
-  const prompt = buildPrompt(discussionUrl, discussion, context, t);
+  const prompt = buildPrompt(discussionUrl, discussion, context, t, repoContext);
   const { content, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
     model,
     systemMessage:
@@ -191,6 +270,61 @@ 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}`);
+    }
+  }
+
+  // Guard: never dispatch workflows from the SDK repo itself (agentic-lib)
+  const isSdkRepo = process.env.GITHUB_REPOSITORY === "xn-intenton-z2a/agentic-lib";
+
+  // Request supervisor evaluation
+  if (action === "request-supervisor") {
+    if (isSdkRepo) {
+      core.info("Skipping supervisor dispatch — running in SDK repo");
+    } else {
+      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") {
+    if (isSdkRepo) {
+      core.info("Skipping schedule dispatch — running in SDK repo");
+    } else {
+      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/review-issue.js

@@ -60,6 +60,24 @@ async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, ins
 
   const agentInstructions = instructions || "Review whether this issue has been resolved by the current codebase.";
 
+  // Gather recent commits since init for context
+  let recentCommitsSummary = [];
+  try {
+    const initTimestamp = config.init?.timestamp || null;
+    const since = initTimestamp || new Date(Date.now() - 7 * 86400000).toISOString();
+    const { data: commits } = await octokit.rest.repos.listCommits({
+      ...repo,
+      sha: "main",
+      since,
+      per_page: 10,
+    });
+    recentCommitsSummary = commits.map((c) => {
+      const msg = c.commit.message.split("\n")[0];
+      const sha = c.sha.substring(0, 7);
+      return `- [${sha}] ${msg} (${c.commit.author?.date || ""})`;
+    });
+  } catch { /* ignore */ }
+
   const prompt = [
     "## Instructions",
     agentInstructions,
@@ -84,6 +102,9 @@ async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, ins
     ...(docsFiles.length > 0
       ? [`## Documentation (${docsFiles.length} files)`, ...docsFiles.map((f) => `- ${f.name}`), ""]
       : []),
+    ...(recentCommitsSummary.length > 0
+      ? [`## Recent Commits (since init)`, ...recentCommitsSummary, ""]
+      : []),
     config.configToml ? `## Configuration (agentic-lib.toml)\n\`\`\`toml\n${config.configToml}\n\`\`\`` : "",
     config.packageJson ? `## Dependencies (package.json)\n\`\`\`json\n${config.packageJson}\n\`\`\`` : "",
     "",

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",
@@ -68,13 +110,55 @@ async function gatherContext(octokit, repo, config, t) {
     return `#${pr.number}: ${pr.title} (${pr.head.ref}) [${labels || "no labels"}] (${age}d old)`;
   });
 
+  // Read init timestamp for epoch boundary
+  const initTimestamp = config.init?.timestamp || null;
+
   let workflowsSummary = [];
+  let actionsSinceInit = [];
   try {
     const { data: runs } = await octokit.rest.actions.listWorkflowRunsForRepo({
       ...repo,
-      per_page: 10,
+      per_page: 20,
     });
     workflowsSummary = runs.workflow_runs.map((r) => `${r.name}: ${r.conclusion || r.status} (${r.created_at})`);
+
+    // Build detailed actions-since-init with commit context
+    const initDate = initTimestamp ? new Date(initTimestamp) : null;
+    const relevantRuns = initDate
+      ? runs.workflow_runs.filter((r) => new Date(r.created_at) >= initDate)
+      : runs.workflow_runs.slice(0, 10);
+
+    for (const run of relevantRuns) {
+      const commit = run.head_commit;
+      const entry = {
+        name: run.name,
+        conclusion: run.conclusion || run.status,
+        created: run.created_at,
+        commitMessage: commit?.message?.split("\n")[0] || "",
+        commitSha: run.head_sha?.substring(0, 7) || "",
+        branch: run.head_branch || "",
+      };
+
+      // For transform branches, try to get PR change stats
+      if (run.head_branch?.startsWith("agentic-lib-issue-")) {
+        try {
+          const { data: prs } = await octokit.rest.pulls.list({
+            ...repo,
+            head: `${repo.owner}:${run.head_branch}`,
+            state: "all",
+            per_page: 1,
+          });
+          if (prs.length > 0) {
+            entry.prNumber = prs[0].number;
+            entry.prTitle = prs[0].title;
+            entry.additions = prs[0].additions;
+            entry.deletions = prs[0].deletions;
+            entry.changedFiles = prs[0].changed_files;
+          }
+        } catch { /* ignore */ }
+      }
+      actionsSinceInit.push(entry);
+    }
   } catch (err) {
     core.warning(`Could not fetch workflow runs: ${err.message}`);
   }
@@ -90,6 +174,8 @@ async function gatherContext(octokit, repo, config, t) {
     oldestReadyIssue,
     prsSummary,
     workflowsSummary,
+    actionsSinceInit,
+    initTimestamp,
     supervisor: config.supervisor,
     configToml: config.configToml,
     packageJson: config.packageJson,
@@ -98,7 +184,11 @@ async function gatherContext(octokit, repo, config, t) {
     activeDiscussionUrl,
     missionComplete,
     missionCompleteInfo,
+    missionFailed,
+    missionFailedInfo,
     transformationBudget,
+    cumulativeTransformationCost,
+    recentlyClosedSummary,
   };
 }
 
@@ -114,6 +204,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",
     "",
@@ -126,6 +219,20 @@ function buildPrompt(ctx, agentInstructions) {
     `### Recent Workflow Runs`,
     ctx.workflowsSummary.join("\n") || "none",
     "",
+    ...(ctx.actionsSinceInit.length > 0
+      ? [
+          `### Actions Since Last Init${ctx.initTimestamp ? ` (${ctx.initTimestamp})` : ""}`,
+          "Each entry: workflow | outcome | commit | branch | changes",
+          ...ctx.actionsSinceInit.map((a) => {
+            let line = `- ${a.name}: ${a.conclusion} (${a.created}) [${a.commitSha}] ${a.commitMessage}`;
+            if (a.prNumber) {
+              line += ` — PR #${a.prNumber}: +${a.additions}/-${a.deletions} in ${a.changedFiles} file(s)`;
+            }
+            return line;
+          }),
+          "",
+        ]
+      : []),
     `### Recent Activity`,
     ctx.recentActivity || "none",
     "",
@@ -150,8 +257,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 +292,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.",
     "",
@@ -227,6 +347,12 @@ async function executeDispatch(octokit, repo, actionName, params) {
   if (params["pr-number"]) inputs["pr-number"] = params["pr-number"];
   if (params["issue-number"]) inputs["issue-number"] = params["issue-number"];
 
+  // Guard: never dispatch workflows from the SDK repo itself (agentic-lib)
+  if (process.env.GITHUB_REPOSITORY === "xn-intenton-z2a/agentic-lib") {
+    core.info(`Skipping dispatch of ${workflowFile} — running in SDK repo`);
+    return `skipped:sdk-repo:${workflowFile}`;
+  }
+
   // Guard: skip transform dispatch if one is already running
   if (workflowFile === "agentic-lib-workflow.yml") {
     try {
@@ -253,6 +379,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}`;
@@ -283,6 +434,10 @@ async function executeRespondDiscussions(octokit, repo, params) {
   const message = params.message || "";
   const url = params["discussion-url"] || "";
   if (message) {
+    if (process.env.GITHUB_REPOSITORY === "xn-intenton-z2a/agentic-lib") {
+      core.info("Skipping bot dispatch — running in SDK repo");
+      return `skipped:sdk-repo:respond-discussions`;
+    }
     core.info(`Dispatching discussions bot with response: ${message.substring(0, 100)}`);
     const inputs = { message };
     if (url) inputs["discussion-url"] = url;
@@ -297,11 +452,69 @@ 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}`);
+  if (process.env.GITHUB_REPOSITORY !== "xn-intenton-z2a/agentic-lib") {
+    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}`);
+  if (process.env.GITHUB_REPOSITORY !== "xn-intenton-z2a/agentic-lib") {
+    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) {
@@ -309,6 +522,10 @@ async function executeSetSchedule(octokit, repo, frequency) {
   if (!valid.includes(frequency)) {
     return `skipped:invalid-frequency:${frequency}`;
   }
+  if (process.env.GITHUB_REPOSITORY === "xn-intenton-z2a/agentic-lib") {
+    core.info(`Skipping schedule dispatch — running in SDK repo`);
+    return `skipped:sdk-repo:set-schedule:${frequency}`;
+  }
   core.info(`Setting supervisor schedule to: ${frequency}`);
   await octokit.rest.actions.createWorkflowDispatch({
     ...repo,
@@ -370,6 +587,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 +606,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/actions/commit-if-changed/action.yml

@@ -26,6 +26,8 @@ runs:
         git config --local user.email 'action@github.com'
         git config --local user.name 'GitHub Actions[bot]'
         git add -A
+        # Unstage workflow files — GITHUB_TOKEN cannot push workflow changes
+        git reset HEAD -- '.github/workflows/' 2>/dev/null || true
         # Unstage log files on non-default branches to avoid merge conflicts
         REF="${{ inputs.push-ref }}"
         if [ -n "$REF" ] && [ "$REF" != "main" ] && [ "$REF" != "master" ]; then

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-index.html

@@ -14,9 +14,6 @@
     .identity { background: #f6f8fa; padding: 1rem; border-radius: 6px; margin: 1rem 0; font-family: monospace; }
     .identity dt { font-weight: bold; color: #666; }
     .identity dd { margin: 0 0 0.5rem 0; font-size: 1.1rem; }
-    .social { display: flex; gap: 1rem; margin: 1rem 0; flex-wrap: wrap; }
-    .social a { display: inline-block; padding: 0.4rem 0.8rem; border: 1px solid #ddd; border-radius: 4px; text-decoration: none; font-size: 0.9rem; }
-    .social a:hover { background: #f6f8fa; }
     #demo-output { background: #1e1e1e; color: #d4d4d4; padding: 1rem; border-radius: 6px; font-family: monospace; white-space: pre-wrap; min-height: 2rem; }
   </style>
 </head>
@@ -32,12 +29,6 @@
   </div>
   <h2>Output</h2>
   <div id="demo-output">Loading library...</div>
-  <h2>Links</h2>
-  <div class="social">
-    <a id="share-github" href="https://github.com/xn-intenton-z2a/repository0" target="_blank" rel="noopener">GitHub</a>
-    <a id="share-twitter" href="#" target="_blank" rel="noopener">X/Twitter</a>
-    <a id="share-linkedin" href="#" target="_blank" rel="noopener">LinkedIn</a>
-  </div>
   <h2>About</h2>
   <p>This website uses the library. See <a href="https://github.com/xn-intenton-z2a/repository0">the repository</a> for source code and mission details.</p>
   <script type="module">
@@ -48,10 +39,6 @@
       document.getElementById('lib-description').textContent = description || '(no description)';
       document.getElementById('demo-output').textContent = JSON.stringify({ name, version, description }, null, 2);
       document.title = name + ' v' + version;
-      const pageUrl = encodeURIComponent(window.location.href);
-      const text = encodeURIComponent('Check out ' + name + ' v' + version + ' — ' + description);
-      document.getElementById('share-twitter').href = 'https://x.com/intent/tweet?url=' + pageUrl + '&text=' + text;
-      document.getElementById('share-linkedin').href = 'https://www.linkedin.com/sharing/share-offsite/?url=' + pageUrl;
     } catch (e) {
       document.getElementById('lib-version').textContent = '(build required)';
       document.getElementById('lib-description').textContent = 'Run npm run build:web to generate library metadata';

package/src/seeds/zero-package.json

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

package/src/seeds/zero-web.test.js

@@ -25,9 +25,4 @@ describe("Website", () => {
     expect(html).toContain("lib-name");
     expect(html).toContain("lib-version");
   });
-
-  test("index.html has social share links", () => {
-    const html = readFileSync("src/web/index.html", "utf8");
-    expect(html).toMatch(/share.*(twitter|x\.com|linkedin)/is);
-  });
 });