@xn-intenton-z2a/agentic-lib 7.1.94 → 7.1.96

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

@@ -107,6 +107,18 @@ jobs:
             let content = fs.readFileSync(workflowPath, 'utf8');
             const cron = SCHEDULE_MAP[frequency];
 
+            // Check if the frequency is already set — skip if no-op
+            const supervisorRegex2 = /^\s*supervisor\s*=\s*"([^"]*)"/m;
+            if (fs.existsSync(tomlPath)) {
+              const currentToml = fs.readFileSync(tomlPath, 'utf8');
+              const currentMatch = currentToml.match(supervisorRegex2);
+              const currentFreq = currentMatch ? currentMatch[1] : '';
+              if (currentFreq === frequency) {
+                core.info(`Schedule already set to ${frequency} — no change needed`);
+                return;
+              }
+            }
+
             // Remove any existing schedule block
             content = content.replace(/\n  schedule:\n    - cron: "[^"]*"\n/g, '\n');
 

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

@@ -11,6 +11,10 @@
 name: agentic-lib-test
 run-name: "agentic-lib-test [${{ github.ref_name }}]"
 
+#@dist concurrency:
+#@dist   group: agentic-lib-test-${{ github.ref_name }}
+#@dist   cancel-in-progress: true
+
 on:
   schedule:
     - cron: "10 * * * *"
@@ -115,12 +119,33 @@ jobs:
     if: >-
       !cancelled()
       && github.ref == 'refs/heads/main'
-      && github.event_name != 'pull_request'
+      && (github.event_name == 'push' || github.event_name == 'schedule')
       && github.repository != 'xn-intenton-z2a/agentic-lib'
       && (needs.test.result == 'failure' || needs.behaviour.result == 'failure')
     runs-on: ubuntu-latest
     steps:
+      - name: Check circuit breaker
+        id: breaker
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Count agentic-lib-workflow dispatches in last 30 minutes
+          SINCE=$(date -u -d '30 minutes ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-30M +%Y-%m-%dT%H:%M:%SZ)
+          COUNT=$(gh run list \
+            --repo "${{ github.repository }}" \
+            --workflow agentic-lib-workflow.yml \
+            --json createdAt \
+            --jq "[.[] | select(.createdAt >= \"$SINCE\")] | length")
+          echo "recent-dispatches=$COUNT"
+          if [ "$COUNT" -ge 3 ]; then
+            echo "Circuit breaker tripped: $COUNT dispatches in last 30 min"
+            echo "tripped=true" >> $GITHUB_OUTPUT
+          else
+            echo "tripped=false" >> $GITHUB_OUTPUT
+          fi
+
       - name: Dispatch agentic-lib-workflow to fix broken build
+        if: steps.breaker.outputs.tripped != 'true'
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |

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

@@ -11,9 +11,9 @@
 
 name: agentic-lib-workflow
 run-name: "agentic-lib-workflow [${{ github.ref_name }}]"
-concurrency:
-  group: agentic-lib-workflow
-  cancel-in-progress: false
+#@dist concurrency:
+#@dist   group: agentic-lib-workflow
+#@dist   cancel-in-progress: false
 
 on:
   #@dist schedule:
@@ -123,13 +123,25 @@ jobs:
   params:
     runs-on: ubuntu-latest
     steps:
+      - uses: actions/checkout@v6
+        with:
+          sparse-checkout: ${{ env.configPath }}
+          sparse-checkout-cone-mode: false
       - name: Normalise params
         id: normalise
         shell: bash
         run: |
           MODEL='${{ inputs.model }}'
+          if [ -z "$MODEL" ] && [ -f "${{ env.configPath }}" ]; then
+            TOML_MODEL=$(grep '^\s*model' "${{ env.configPath }}" | head -1 | sed 's/.*= *"\([^"]*\)".*/\1/')
+            MODEL="${TOML_MODEL}"
+          fi
           echo "model=${MODEL:-gpt-5-mini}" >> $GITHUB_OUTPUT
           PROFILE='${{ inputs.profile }}'
+          if [ -z "$PROFILE" ] && [ -f "${{ env.configPath }}" ]; then
+            TOML_PROFILE=$(grep '^\s*profile' "${{ env.configPath }}" | head -1 | sed 's/.*= *"\([^"]*\)".*/\1/')
+            PROFILE="${TOML_PROFILE}"
+          fi
           echo "profile=${PROFILE}" >> $GITHUB_OUTPUT
           MODE='${{ inputs.mode }}'
           echo "mode=${MODE:-full}" >> $GITHUB_OUTPUT
@@ -242,6 +254,52 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install dependencies (non-blocking)
+        id: install-deps
+        run: npm ci 2>/dev/null || echo "npm ci failed (non-blocking)"
+
+      - name: Run unit tests (non-blocking)
+        id: unit-tests
+        run: |
+          set +e
+          TEST_CMD=""
+          if [ -f agentic-lib.toml ]; then
+            TEST_CMD=$(grep '^\s*test\s*=' agentic-lib.toml 2>/dev/null | head -1 | sed 's/.*=\s*"\([^"]*\)".*/\1/')
+          fi
+          TEST_CMD="${TEST_CMD:-npm test}"
+          OUTPUT=$(eval "$TEST_CMD" 2>&1)
+          EXIT_CODE=$?
+          echo "exit-code=$EXIT_CODE" >> $GITHUB_OUTPUT
+          PASS_COUNT=$(echo "$OUTPUT" | grep -oP '\d+ pass' | head -1 | grep -oP '\d+' || echo "0")
+          FAIL_COUNT=$(echo "$OUTPUT" | grep -oP '\d+ fail' | head -1 | grep -oP '\d+' || echo "0")
+          echo "pass-count=$PASS_COUNT" >> $GITHUB_OUTPUT
+          echo "fail-count=$FAIL_COUNT" >> $GITHUB_OUTPUT
+          echo "$OUTPUT" | tail -100 > /tmp/unit-test-output.txt
+          exit 0
+
+      - name: Run behaviour tests (non-blocking)
+        id: behaviour-tests
+        if: hashFiles('playwright.config.js') != '' || hashFiles('playwright.config.ts') != ''
+        run: |
+          set +e
+          npx playwright install --with-deps chromium 2>/dev/null || true
+          npm run build:web 2>/dev/null || true
+          OUTPUT=$(npm run --if-present test:behaviour 2>&1)
+          EXIT_CODE=$?
+          echo "exit-code=$EXIT_CODE" >> $GITHUB_OUTPUT
+          PASS_COUNT=$(echo "$OUTPUT" | grep -oP '\d+ passed' | head -1 | grep -oP '\d+' || echo "0")
+          FAIL_COUNT=$(echo "$OUTPUT" | grep -oP '\d+ failed' | head -1 | grep -oP '\d+' || echo "0")
+          echo "pass-count=$PASS_COUNT" >> $GITHUB_OUTPUT
+          echo "fail-count=$FAIL_COUNT" >> $GITHUB_OUTPUT
+          echo "$OUTPUT" | tail -50 > /tmp/behaviour-test-output.txt
+          exit 0
+
       - name: Gather telemetry
         id: gather
         uses: actions/github-script@v8
@@ -293,6 +351,72 @@ jobs:
             // Message from bot/human
             const message = '${{ needs.params.outputs.message }}';
 
+            // Latest external test workflow run
+            let externalTestResults = null;
+            try {
+              const testRuns = await github.rest.actions.listWorkflowRuns({
+                owner, repo,
+                workflow_id: 'agentic-lib-test.yml',
+                branch: 'main',
+                per_page: 1,
+              });
+              const latestTest = testRuns.data.workflow_runs[0];
+              if (latestTest) {
+                const jobs = await github.rest.actions.listJobsForWorkflowRun({
+                  owner, repo,
+                  run_id: latestTest.id,
+                });
+                externalTestResults = {
+                  runId: latestTest.id,
+                  conclusion: latestTest.conclusion,
+                  created: latestTest.created_at,
+                  jobs: jobs.data.jobs.map(j => ({
+                    name: j.name, conclusion: j.conclusion,
+                  })),
+                };
+              }
+            } catch (e) { /* ignore */ }
+
+            // Source file stats
+            let sourceStats = null;
+            try {
+              const sourcePath = 'src/lib/';
+              if (fs.existsSync(sourcePath)) {
+                const files = fs.readdirSync(sourcePath).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+                sourceStats = files.map(f => {
+                  const content = fs.readFileSync(`${sourcePath}${f}`, 'utf8');
+                  const lines = content.split('\n').length;
+                  const exports = [...content.matchAll(/export\s+(?:async\s+)?(?:function|const|class)\s+(\w+)/g)].map(m => m[1]);
+                  return { file: f, lines, exports };
+                });
+              }
+            } catch (e) {}
+
+            // Mission complete/failed signals
+            const missionComplete = fs.existsSync('MISSION_COMPLETE.md');
+            const missionFailed = fs.existsSync('MISSION_FAILED.md');
+
+            // Activity log stats
+            let activityStats = null;
+            try {
+              const logPath = fs.existsSync('intenti\u00F6n.md') ? 'intenti\u00F6n.md' : (fs.existsSync('intention.md') ? 'intention.md' : null);
+              if (logPath) {
+                const log = fs.readFileSync(logPath, 'utf8');
+                const entries = log.split('\n## ').length - 1;
+                const costMatches = [...log.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g)];
+                const totalCost = costMatches.reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+                activityStats = { entries, totalTransformCost: totalCost };
+              }
+            } catch (e) {}
+
+            // Live test results from earlier steps
+            const unitOutput = fs.existsSync('/tmp/unit-test-output.txt')
+              ? fs.readFileSync('/tmp/unit-test-output.txt', 'utf8').slice(0, 5000)
+              : '';
+            const behaviourOutput = fs.existsSync('/tmp/behaviour-test-output.txt')
+              ? fs.readFileSync('/tmp/behaviour-test-output.txt', 'utf8').slice(0, 2500)
+              : '';
+
             const telemetry = {
               issues: issuesSummary,
               prs: prsSummary,
@@ -300,13 +424,42 @@ jobs:
               mission: mission.slice(0, 500),
               featureFiles: features,
               message: message || null,
+              liveTests: {
+                unit: {
+                  exitCode: parseInt('${{ steps.unit-tests.outputs.exit-code }}' || '0'),
+                  passCount: parseInt('${{ steps.unit-tests.outputs.pass-count }}' || '0'),
+                  failCount: parseInt('${{ steps.unit-tests.outputs.fail-count }}' || '0'),
+                  output: unitOutput,
+                },
+                behaviour: {
+                  exitCode: parseInt('${{ steps.behaviour-tests.outputs.exit-code }}' || '-1'),
+                  passCount: parseInt('${{ steps.behaviour-tests.outputs.pass-count }}' || '0'),
+                  failCount: parseInt('${{ steps.behaviour-tests.outputs.fail-count }}' || '0'),
+                  output: behaviourOutput,
+                },
+              },
+              externalTestResults,
+              sourceStats,
+              activityStats,
+              missionComplete,
+              missionFailed,
             };
 
             // Write to file for downstream jobs
             fs.writeFileSync('/tmp/telemetry.json', JSON.stringify(telemetry, null, 2));
-            // Set as output (truncated for GitHub output limits)
+            // Set as output (clipped by tuning profile)
+            let maxTelemetryChars = 30000;
+            try {
+              if (fs.existsSync('agentic-lib.toml')) {
+                const toml = fs.readFileSync('agentic-lib.toml', 'utf8');
+                const profileMatch = toml.match(/^\s*profile\s*=\s*"(\w+)"/m);
+                const profile = profileMatch ? profileMatch[1] : 'recommended';
+                const PROFILE_LIMITS = { min: 10000, recommended: 30000, max: 60000 };
+                maxTelemetryChars = PROFILE_LIMITS[profile] || 30000;
+              }
+            } catch (e) {}
             const summary = JSON.stringify(telemetry);
-            core.setOutput('telemetry', summary.slice(0, 60000));
+            core.setOutput('telemetry', summary.slice(0, maxTelemetryChars));
     outputs:
       telemetry: ${{ steps.gather.outputs.telemetry }}
 
@@ -688,6 +841,8 @@ jobs:
             echo "No changes to commit"
             exit 0
           fi
+          git config --local user.email 'action@github.com'
+          git config --local user.name 'GitHub Actions[bot]'
           git add -A
           git commit -m "agentic-step: fix broken main build (run ${{ env.FIX_RUN_ID }})"
           git push -u origin agentic-lib-fix-main-build
@@ -987,6 +1142,16 @@ jobs:
           echo "- Dry-run: ${{ needs.params.outputs.dry-run }}" >> $GITHUB_STEP_SUMMARY
           echo "- Website: [${SITE_URL}](${SITE_URL})" >> $GITHUB_STEP_SUMMARY
 
+  # ─── Post-commit validation: call test workflow to verify branch health ───
+  post-commit-test:
+    needs: [params, dev, fix-stuck, post-merge]
+    if: >-
+      !cancelled()
+      && needs.params.outputs.dry-run != 'true'
+      && needs.params.result == 'success'
+    uses: ./.github/workflows/agentic-lib-test.yml
+    secrets: inherit
+
   # ─── Schedule change (if requested) ────────────────────────────────
   update-schedule:
     needs: [params, dev]

package/agentic-lib.toml

@@ -12,6 +12,7 @@ supervisor = "daily"              # off | weekly | daily | hourly | continuous
 mission = "test/MISSION.md"                     #@dist "MISSION.md"
 source = "test/src/lib/"                        #@dist "src/lib/"
 tests = "test/tests/unit/"                      #@dist "tests/unit/"
+behaviour = "test/tests/behaviour/"             #@dist "tests/behaviour/"
 features = "test/features/"                     #@dist "features/"
 library = "test/library/"                       #@dist "library/"
 web = "test/src/web/"                            #@dist "src/web/"

package/bin/agentic-lib.js

@@ -905,6 +905,7 @@ function initReseed(initTimestamp) {
 function readTomlPaths() {
   let sourcePath = "src/lib/";
   let testsPath = "tests/unit/";
+  let behaviourPath = "tests/behaviour/";
   let examplesPath = "examples/";
   let webPath = "src/web/";
   const tomlTarget = resolve(target, "agentic-lib.toml");
@@ -913,17 +914,19 @@ function readTomlPaths() {
       const tomlContent = readFileSync(tomlTarget, "utf8");
       const sourceMatch = tomlContent.match(/^source\s*=\s*"([^"]+)"/m);
       const testsMatch = tomlContent.match(/^tests\s*=\s*"([^"]+)"/m);
+      const behaviourMatch = tomlContent.match(/^behaviour\s*=\s*"([^"]+)"/m);
       const examplesMatch = tomlContent.match(/^examples\s*=\s*"([^"]+)"/m);
       const webMatch = tomlContent.match(/^web\s*=\s*"([^"]+)"/m);
       if (sourceMatch) sourcePath = sourceMatch[1];
       if (testsMatch) testsPath = testsMatch[1];
+      if (behaviourMatch) behaviourPath = behaviourMatch[1];
       if (examplesMatch) examplesPath = examplesMatch[1];
       if (webMatch) webPath = webMatch[1];
     } catch (err) {
       console.log(`  WARN: Could not read TOML for paths, using defaults: ${err.message}`);
     }
   }
-  return { sourcePath, testsPath, examplesPath, webPath };
+  return { sourcePath, testsPath, behaviourPath, examplesPath, webPath };
 }
 
 function clearAndRecreateDir(dirPath, label) {
@@ -939,9 +942,10 @@ function clearAndRecreateDir(dirPath, label) {
 function initPurge(seedsDir, missionName, initTimestamp) {
   console.log("\n--- Purge: Reset Source Files to Seed State ---");
 
-  const { sourcePath, testsPath, examplesPath, webPath } = readTomlPaths();
+  const { sourcePath, testsPath, behaviourPath, examplesPath, webPath } = readTomlPaths();
   clearAndRecreateDir(sourcePath, sourcePath);
   clearAndRecreateDir(testsPath, testsPath);
+  clearAndRecreateDir(behaviourPath, behaviourPath);
   clearAndRecreateDir(examplesPath, examplesPath);
   clearAndRecreateDir(webPath, webPath);
   clearAndRecreateDir("docs", "docs");
@@ -1097,25 +1101,53 @@ function initPurgeGitHub() {
     }
     if (openIssues.length === 0) console.log("  No open issues to close");
 
-    // Lock ALL issues (open and closed) to prevent bleed
+    // Blank + lock ALL issues (open and closed) to prevent bleed from old missions
     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);
+    const allIssues = JSON.parse(allIssuesJson || "[]").filter((i) => !i.pull_request);
+    let blanked = 0;
     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`,
-          );
+      const needsBlank = issue.title !== "unused github issue";
+      const needsLock = !issue.locked;
+      if (!needsBlank && !needsLock) continue;
+      if (needsBlank) {
+        console.log(`  BLANK: issue #${issue.number} — "${issue.title}" → "unused github issue"`);
+        if (!dryRun) {
+          try {
+            ghExec(
+              `gh api repos/${repoSlug}/issues/${issue.number} -X PATCH -f title="unused github issue" -f body="unused github issue"`,
+            );
+            // Remove all labels
+            try {
+              ghExec(`gh api repos/${repoSlug}/issues/${issue.number}/labels -X DELETE`);
+            } catch { /* no labels to remove */ }
+            blanked++;
+            initChanges++;
+          } catch (err) {
+            console.log(`  WARN: Failed to blank issue #${issue.number}: ${err.message}`);
+          }
+        } else {
+          blanked++;
+          initChanges++;
+        }
+      }
+      if (needsLock) {
+        console.log(`  LOCK: issue #${issue.number}`);
+        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++;
-        } 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");
+    if (blanked > 0) console.log(`  Blanked ${blanked} issue(s)`);
+    if (allIssues.length === 0) console.log("  No issues to process");
   } catch (err) {
     console.log(`  WARN: Issue cleanup failed: ${err.message}`);
   }

package/package.json

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

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

@@ -35,13 +35,14 @@ import { parse as parseToml } from "smol-toml";
  */
 
 // Keys whose paths are writable by agents
-const WRITABLE_KEYS = ["source", "tests", "features", "dependencies", "docs", "readme", "examples", "web"];
+const WRITABLE_KEYS = ["source", "tests", "behaviour", "features", "dependencies", "docs", "readme", "examples", "web"];
 
 // Default paths — every key that task handlers might access
 const PATH_DEFAULTS = {
   mission: "MISSION.md",
   source: "src/lib/",
   tests: "tests/unit/",
+  behaviour: "tests/behaviour/",
   features: "features/",
   docs: "docs/",
   examples: "examples/",

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

@@ -34,6 +34,65 @@ const TASKS = {
   "supervise": supervise,
 };
 
+/**
+ * Build mission-complete metrics array for the intentïon.md dashboard.
+ */
+function buildMissionMetrics(config, result, limitsStatus, cumulativeCost, featureIssueCount, maintenanceIssueCount) {
+  const openIssues = featureIssueCount + maintenanceIssueCount;
+  const budgetCap = config.transformationBudget || 0;
+  const resolvedCount = result.resolvedCount || 0;
+  const missionComplete = existsSync("MISSION_COMPLETE.md");
+  const missionFailed = existsSync("MISSION_FAILED.md");
+
+  // Count open PRs from result if available
+  const openPrs = result.openPrCount || 0;
+
+  const metrics = [
+    { metric: "Open issues", value: String(openIssues), target: "0", status: openIssues === 0 ? "MET" : "NOT MET" },
+    { metric: "Open PRs", value: String(openPrs), target: "0", status: openPrs === 0 ? "MET" : "NOT MET" },
+    { metric: "Issues closed by review (RESOLVED)", value: String(resolvedCount), target: ">= 1", status: resolvedCount >= 1 ? "MET" : "NOT MET" },
+    { metric: "Transformation budget used", value: `${cumulativeCost}/${budgetCap}`, target: budgetCap > 0 ? `< ${budgetCap}` : "unlimited", status: budgetCap > 0 && cumulativeCost >= budgetCap ? "EXHAUSTED" : "OK" },
+    { metric: "Cumulative transforms", value: String(cumulativeCost), target: ">= 1", status: cumulativeCost >= 1 ? "MET" : "NOT MET" },
+    { metric: "Mission complete declared", value: missionComplete ? "YES" : "NO", target: "—", status: "—" },
+    { metric: "Mission failed declared", value: missionFailed ? "YES" : "NO", target: "—", status: "—" },
+  ];
+
+  return metrics;
+}
+
+/**
+ * Build mission-complete readiness narrative from metrics.
+ */
+function buildMissionReadiness(metrics) {
+  const openIssues = parseInt(metrics.find((m) => m.metric === "Open issues")?.value || "0", 10);
+  const openPrs = parseInt(metrics.find((m) => m.metric === "Open PRs")?.value || "0", 10);
+  const resolved = parseInt(metrics.find((m) => m.metric === "Issues closed by review (RESOLVED)")?.value || "0", 10);
+  const missionComplete = metrics.find((m) => m.metric === "Mission complete declared")?.value === "YES";
+  const missionFailed = metrics.find((m) => m.metric === "Mission failed declared")?.value === "YES";
+
+  if (missionComplete) {
+    return "Mission has been declared complete.";
+  }
+  if (missionFailed) {
+    return "Mission has been declared failed.";
+  }
+
+  const conditionsMet = openIssues === 0 && openPrs === 0 && resolved >= 1;
+  const parts = [];
+
+  if (conditionsMet) {
+    parts.push("Mission complete conditions ARE met.");
+    parts.push(`0 open issues, 0 open PRs, ${resolved} issue(s) closed by review as RESOLVED.`);
+  } else {
+    parts.push("Mission complete conditions are NOT met.");
+    if (openIssues > 0) parts.push(`${openIssues} open issue(s) remain.`);
+    if (openPrs > 0) parts.push(`${openPrs} open PR(s) remain.`);
+    if (resolved < 1) parts.push("No issues have been closed by review as RESOLVED yet.");
+  }
+
+  return parts.join(" ");
+}
+
 async function run() {
   try {
     // Parse inputs
@@ -173,6 +232,10 @@ async function run() {
 
     const closingNotes = result.closingNotes || generateClosingNotes(limitsStatus);
 
+    // Build mission-complete metrics and readiness narrative
+    const missionMetrics = buildMissionMetrics(config, result, limitsStatus, cumulativeCost, featureIssueCount, maintenanceIssueCount);
+    const missionReadiness = buildMissionReadiness(missionMetrics);
+
     // Log to intentïon.md (commit-if-changed excludes this on non-default branches)
     if (intentionFilepath) {
       logActivity({
@@ -195,6 +258,8 @@ async function run() {
         contextNotes: result.contextNotes,
         limitsStatus,
         promptBudget: result.promptBudget,
+        missionReadiness,
+        missionMetrics,
         closingNotes,
         transformationCost,
         narrative: result.narrative,

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

@@ -35,6 +35,8 @@ import * as core from "@actions/core";
  * @param {string} [options.closingNotes] - Auto-generated limit concern notes
  * @param {number} [options.transformationCost] - Transformation cost for this entry (0 or 1)
  * @param {string} [options.narrative] - LLM-generated narrative description of the change
+ * @param {string} [options.missionReadiness] - Mission-complete readiness narrative
+ * @param {Array} [options.missionMetrics] - Mission metrics entries { metric, value, target, status }
  */
 export function logActivity({
   filepath,
@@ -56,6 +58,8 @@ export function logActivity({
   contextNotes,
   limitsStatus,
   promptBudget,
+  missionReadiness,
+  missionMetrics,
   closingNotes,
   transformationCost,
   narrative,
@@ -108,6 +112,18 @@ export function logActivity({
       parts.push(`| ${pb.section} | ${pb.size} chars | ${pb.files || "—"} | ${pb.notes || ""} |`);
     }
   }
+  if (missionReadiness) {
+    parts.push("", "### Mission-Complete Readiness");
+    parts.push(missionReadiness);
+  }
+  if (missionMetrics && missionMetrics.length > 0) {
+    parts.push("", "### Mission Metrics");
+    parts.push("| Metric | Value | Target | Status |");
+    parts.push("|--------|-------|--------|--------|");
+    for (const m of missionMetrics) {
+      parts.push(`| ${m.metric} | ${m.value} | ${m.target} | ${m.status} |`);
+    }
+  }
   if (closingNotes) {
     parts.push("", "### Closing Notes");
     parts.push(closingNotes);

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

@@ -337,23 +337,10 @@ export async function discussions(context) {
   // 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
+  // Request supervisor evaluation — dispatch is handled by the bot workflow's
+  // dispatch-supervisor job, so we just log the action here to avoid double dispatch.
   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}`);
-      }
-    }
+    core.info(`Supervisor requested with message: ${actionArg || "Discussion bot referral"} (dispatch handled by bot workflow)`);
   }
 
   // Stop automation

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

@@ -520,11 +520,12 @@ async function executeDispatch(octokit, repo, actionName, params, ctx) {
   return `dispatched:${workflowFile}`;
 }
 
-async function executeCreateIssue(octokit, repo, params) {
+async function executeCreateIssue(octokit, repo, params, ctx) {
   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
+  // Exclude issues closed before the init timestamp (cross-scenario protection)
   try {
     const { data: recent } = await octokit.rest.issues.listForRepo({
       ...repo,
@@ -533,12 +534,14 @@ async function executeCreateIssue(octokit, repo, params) {
       direction: "desc",
       per_page: 5,
     });
+    const initTimestamp = ctx?.initTimestamp;
     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,
+        Date.now() - new Date(i.closed_at).getTime() < 3600000 &&
+        (!initTimestamp || new Date(i.closed_at) > new Date(initTimestamp)),
     );
     if (duplicate) {
       core.info(`Skipping duplicate issue (similar to recently closed #${duplicate.number})`);

package/src/agents/agent-apply-fix.md

@@ -31,6 +31,10 @@ regardless — each failed attempt consumes transformation budget, so get it rig
 **Both unit tests AND behaviour tests must pass.** The project runs `npm test` (unit tests) and
 `npm run test:behaviour` (Playwright). Both are gated — your fix must pass both.
 
+**IMPORTANT**: The project uses `"type": "module"` in package.json. All files must use ESM syntax:
+- `import { test, expect } from "@playwright/test"` (NOT `const { test, expect } = require(...)`)
+- `import { execSync } from "child_process"` (NOT `const { execSync } = require(...)`)
+
 ## Merge Conflict Resolution
 
 When resolving merge conflicts (files containing <<<<<<< / ======= / >>>>>>> markers):

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

@@ -30,6 +30,10 @@ the website code that uses it, the web tests that check for its output, and any
 that depend on it. A partial change that updates the library but not the tests will fail — and there will
 be a full test run after your changes regardless, consuming budget on each failure.
 
+**IMPORTANT**: The project uses `"type": "module"` in package.json. All files must use ESM syntax:
+- `import { test, expect } from "@playwright/test"` (NOT `const { test, expect } = require(...)`)
+- `import { execSync } from "child_process"` (NOT `const { execSync } = require(...)`)
+
 ## Tests Must Pass
 
 Your changes MUST leave all existing tests passing. If you change function signatures, return values, or

package/src/seeds/zero-package.json

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