@xn-intenton-z2a/agentic-lib 7.4.13 → 7.4.15

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

@@ -8,16 +8,17 @@
 import * as core from "@actions/core";
 import * as github from "@actions/github";
 import { loadConfig, getWritablePaths } from "./config-loader.js";
-import { logActivity, generateClosingNotes, writeAgentLog } from "./logging.js";
-import { readFileSync, existsSync } from "fs";
+import { generateClosingNotes, writeAgentLog } from "./logging.js";
+import { readFileSync, existsSync, readdirSync } from "fs";
 import {
   buildMissionMetrics, buildMissionReadiness,
-  computeTransformationCost, readCumulativeCost, buildLimitsStatus,
+  computeTransformationCost, buildLimitsStatus,
 } from "../../copilot/telemetry.js";
 import {
   checkInstabilityLabel, countDedicatedTests,
   countOpenIssues, countResolvedIssues, countMdFiles,
 } from "./metrics.js";
+import { readState, writeState, updateStateAfterTask } from "../../copilot/state.js";
 
 // Task implementations
 import { resolveIssue } from "./tasks/resolve-issue.js";
@@ -63,9 +64,22 @@ async function run() {
     if (!handler) throw new Error(`Unknown task: ${task}. Available: ${Object.keys(TASKS).join(", ")}`);
 
     // Resolve log and screenshot paths (fetched from agentic-lib-logs branch by workflow)
-    const logFile = config.intentionBot?.intentionFilepath || "intenti\u00F6n.md";
+    const logPrefix = config.intentionBot?.logPrefix || "agent-log-";
     const screenshotFile = config.intentionBot?.screenshotFile || "SCREENSHOT_INDEX.png";
-    const logFilePath = existsSync(logFile) ? logFile : null;
+    // Find the most recent agent-log file matching the prefix for LLM context
+    const logDir = logPrefix.includes("/") ? logPrefix.substring(0, logPrefix.lastIndexOf("/")) : ".";
+    const logBase = logPrefix.includes("/") ? logPrefix.substring(logPrefix.lastIndexOf("/") + 1) : logPrefix;
+    let logFilePath = null;
+    try {
+      const logFiles = readdirSync(logDir)
+        .filter(f => f.startsWith(logBase) && f.endsWith(".md"))
+        .sort();
+      if (logFiles.length > 0) {
+        const newest = logFiles[logFiles.length - 1];
+        const candidate = logDir === "." ? newest : `${logDir}/${newest}`;
+        if (existsSync(candidate)) logFilePath = candidate;
+      }
+    } catch { /* no log files yet */ }
     const screenshotFilePath = existsSync(screenshotFile) ? screenshotFile : null;
 
     const context = {
@@ -79,6 +93,9 @@ async function run() {
       logFilePath, screenshotFilePath,
     };
 
+    // C1: Read persistent state from agentic-lib-state.toml
+    const state = readState(".");
+
     const startTime = Date.now();
     const result = await handler(context);
     const durationMs = Date.now() - startTime;
@@ -96,15 +113,17 @@ async function run() {
       && await checkInstabilityLabel(context, issueNumber);
     if (isInstability) core.info(`Issue #${issueNumber} has instability label — does not count against budget`);
     const transformationCost = computeTransformationCost(task, result.outcome, isInstability);
-    const intentionFilepath = config.intentionBot?.intentionFilepath;
-    const cumulativeCost = readCumulativeCost(intentionFilepath) + transformationCost;
-
-    if (result.dedicatedTestCount == null || result.dedicatedTestCount === 0) {
-      try {
-        const { scanDirectory: scanDir } = await import("./copilot.js");
-        result.dedicatedTestCount = countDedicatedTests(scanDir);
-      } catch { /* ignore */ }
-    }
+
+    // C1/C2: Update persistent state with this task's results
+    updateStateAfterTask(state, {
+      task,
+      outcome: result.outcome || "completed",
+      transformationCost,
+      tokensUsed: result.tokensUsed || 0,
+    });
+    // C2: Use cumulative cost from persistent state (not just this task)
+    const cumulativeCost = state.counters["cumulative-transforms"] || 0;
+    state.budget["transformation-budget-cap"] = config.transformationBudget || 0;
 
     const { featureIssueCount, maintenanceIssueCount } = await countOpenIssues(context);
     if (result.resolvedCount == null) result.resolvedCount = await countResolvedIssues(context);
@@ -121,39 +140,37 @@ async function run() {
       }
     }
 
-    const missionMetrics = buildMissionMetrics(config, result, limitsStatus, cumulativeCost, featureIssueCount, maintenanceIssueCount);
-
-    if (intentionFilepath) {
-      logActivity({
-        filepath: intentionFilepath, task, outcome: result.outcome || "completed",
-        issueNumber, prNumber: result.prNumber, commitUrl: result.commitUrl,
-        tokensUsed: result.tokensUsed, inputTokens: result.inputTokens,
-        outputTokens: result.outputTokens, cost: result.cost, durationMs,
-        model: result.model || model, details: result.details,
-        workflowUrl: `${process.env.GITHUB_SERVER_URL}/${github.context.repo.owner}/${github.context.repo.repo}/actions/runs/${github.context.runId}`,
-        profile: config.tuning?.profileName || "unknown",
-        changes: result.changes, contextNotes: result.contextNotes,
-        limitsStatus, promptBudget: result.promptBudget,
-        missionReadiness: buildMissionReadiness(missionMetrics),
-        missionMetrics, closingNotes: result.closingNotes || generateClosingNotes(limitsStatus),
-        transformationCost, narrative: result.narrative,
-      });
-    }
+    // C5: Pass per-task costs for split display
+    const taskCosts = {
+      transformationCost,
+      tokensUsed: result.tokensUsed || 0,
+      cumulativeTokens: state.counters["total-tokens"] || 0,
+    };
+    const missionMetrics = buildMissionMetrics(config, result, limitsStatus, cumulativeCost, featureIssueCount, maintenanceIssueCount, taskCosts);
 
-    // Write standalone agent log file (pushed to agentic-lib-logs branch by workflow)
+    // C4: Write standalone agent log file with sequence number
+    const seq = state.counters["log-sequence"] || 0;
     try {
       const agentLogFile = writeAgentLog({
         task, outcome: result.outcome || "completed",
         model: result.model || model, durationMs, tokensUsed: result.tokensUsed,
         narrative: result.narrative, contextNotes: result.contextNotes,
         reviewTable: result.reviewTable, completenessAdvice: result.completenessAdvice,
-        missionMetrics,
+        missionMetrics, sequence: seq,
       });
       core.info(`Agent log written: ${agentLogFile}`);
     } catch (err) {
       core.warning(`Could not write agent log: ${err.message}`);
     }
 
+    // C1: Write updated state back to agentic-lib-state.toml
+    try {
+      writeState(".", state);
+      core.info(`State written: seq=${seq}, transforms=${cumulativeCost}, nops=${state.counters["cumulative-nop-cycles"]}`);
+    } catch (err) {
+      core.warning(`Could not write state: ${err.message}`);
+    }
+
     core.info(`agentic-step completed: outcome=${result.outcome}`);
   } catch (error) {
     core.setFailed(`agentic-step failed: ${error.message}`);

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

@@ -5,8 +5,8 @@
 // Appends structured entries to the intentïon.md activity log,
 // including commit URLs and safety-check outcomes.
 
-import { writeFileSync, readFileSync, appendFileSync, existsSync, mkdirSync, copyFileSync, readdirSync } from "fs";
-import { dirname, basename } from "path";
+import { writeFileSync, readFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { dirname } from "path";
 import { join } from "path";
 import * as core from "@actions/core";
 
@@ -160,16 +160,6 @@ export function logActivity({
     writeFileSync(filepath, `# intentïon Activity Log\n${entry}`);
   }
 
-  // Write ASCII fallback copy (intention.md) for systems that can't handle UTF-8 filenames
-  const name = basename(filepath);
-  if (name !== "intention.md" && name.includes("intenti")) {
-    const fallbackPath = join(dirname(filepath), "intention.md");
-    try {
-      copyFileSync(filepath, fallbackPath);
-    } catch {
-      // Best-effort — don't fail the log if the copy fails
-    }
-  }
 }
 
 /**
@@ -192,16 +182,19 @@ export function logActivity({
 export function writeAgentLog({
   task, outcome, model, durationMs, narrative,
   reviewTable, completenessAdvice, contextNotes,
-  missionMetrics, tokensUsed,
+  missionMetrics, tokensUsed, sequence,
 }) {
   const now = new Date();
   const stamp = now.toISOString().replace(/:/g, "-").replace(/\./g, "-");
-  const filename = `agent-log-${stamp}.md`;
+  // C4: Include zero-padded sequence number in filename
+  const seq = String(sequence || 0).padStart(3, "0");
+  const filename = `agent-log-${stamp}-${seq}.md`;
 
   const parts = [
     `# Agent Log: ${task} at ${now.toISOString()}`,
     "",
     "## Summary",
+    `**Sequence:** ${seq}`,
     `**Task:** ${task}`,
     `**Outcome:** ${outcome}`,
   ];

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

@@ -68,7 +68,6 @@ function detectDedicatedTests() {
 function buildMetricAssessment(ctx, config) {
   const thresholds = config.missionCompleteThresholds || {};
   const minResolved = thresholds.minResolvedIssues ?? 3;
-  const minTests = thresholds.minDedicatedTests ?? 1;
   const maxTodos = thresholds.maxSourceTodos ?? 0;
 
   // Implementation review gaps (passed from workflow via env)
@@ -79,12 +78,13 @@ function buildMetricAssessment(ctx, config) {
   } catch { /* ignore parse errors */ }
   const criticalGaps = reviewGaps.filter((g) => g.severity === "critical");
 
+  // C6: Removed "Dedicated tests" metric; using cumulative transforms instead
   const metrics = [
     { metric: "Open issues", value: ctx.issuesSummary.length, target: 0, met: ctx.issuesSummary.length === 0 },
     { metric: "Open PRs", value: ctx.prsSummary.length, target: 0, met: ctx.prsSummary.length === 0 },
     { metric: "Issues resolved", value: ctx.resolvedCount, target: minResolved, met: ctx.resolvedCount >= minResolved },
-    { metric: "Dedicated tests", value: ctx.dedicatedTestCount, target: minTests, met: ctx.dedicatedTestCount >= minTests },
     { metric: "Source TODOs", value: ctx.sourceTodoCount, target: maxTodos, met: ctx.sourceTodoCount <= maxTodos },
+    { metric: "Cumulative transforms", value: ctx.cumulativeTransformationCost, target: 1, met: ctx.cumulativeTransformationCost >= 1 },
     { metric: "Budget", value: ctx.cumulativeTransformationCost, target: ctx.transformationBudget || "unlimited", met: !(ctx.transformationBudget > 0 && ctx.cumulativeTransformationCost >= ctx.transformationBudget) },
     { metric: "Implementation review", value: criticalGaps.length === 0 ? "No critical gaps" : `${criticalGaps.length} critical gap(s)`, target: "No critical gaps", met: criticalGaps.length === 0 },
   ];
@@ -129,8 +129,8 @@ function buildPrompt(ctx, agentInstructions, metricAssessment) {
     `Open issues: ${ctx.issuesSummary.length}`,
     `Recently closed issues: ${ctx.recentlyClosedSummary.length}`,
     `Open PRs: ${ctx.prsSummary.length}`,
-    `Dedicated test files: ${ctx.dedicatedTestCount}`,
     `Source TODOs: ${ctx.sourceTodoCount}`,
+    `Cumulative transforms: ${ctx.cumulativeTransformationCost}`,
     `Transformation budget: ${ctx.cumulativeTransformationCost}/${ctx.transformationBudget || "unlimited"}`,
     "",
     ...(process.env.REVIEW_ADVICE ? [
@@ -216,18 +216,29 @@ async function executeMissionComplete(octokit, repo, reason) {
 /**
  * Execute mission-failed: write signal file and commit via Contents API.
  */
-async function executeMissionFailed(octokit, repo, reason) {
+async function executeMissionFailed(octokit, repo, reason, metricAssessment) {
+  // C16: Build a detailed reason including specific failed metrics
+  const metricDetail = metricAssessment?.notMet?.length > 0
+    ? `Failed metrics: ${metricAssessment.notMet.map(m => `${m.metric}=${m.value} (target: ${typeof m.target === "number" ? (m.metric.includes("TODO") ? `<= ${m.target}` : `>= ${m.target}`) : m.target})`).join(", ")}.`
+    : reason;
+  const metsMet = metricAssessment?.metrics?.filter(m => m.met).map(m => `${m.metric}=${m.value}`) || [];
+  const detailedReason = metsMet.length > 0
+    ? `${metricDetail} Passing metrics: ${metsMet.join(", ")}.`
+    : metricDetail;
+
   const signal = [
     "# Mission Failed",
     "",
     `- **Timestamp:** ${new Date().toISOString()}`,
     `- **Detected by:** director`,
-    `- **Reason:** ${reason}`,
+    `- **Reason:** ${detailedReason}`,
     "",
     "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);
 
+  // C16: Use detailed commit message
+  const commitMsg = `mission-failed: ${metricDetail.substring(0, 200)}`;
   try {
     const contentBase64 = Buffer.from(signal).toString("base64");
     let existingSha;
@@ -238,7 +249,7 @@ async function executeMissionFailed(octokit, repo, reason) {
     await octokit.rest.repos.createOrUpdateFileContents({
       ...repo,
       path: "MISSION_FAILED.md",
-      message: "mission-failed: " + reason.substring(0, 72),
+      message: commitMsg,
       content: contentBase64,
       branch: "main",
       ...(existingSha ? { sha: existingSha } : {}),
@@ -247,6 +258,33 @@ async function executeMissionFailed(octokit, repo, reason) {
   } catch (err) {
     core.warning(`Could not commit MISSION_FAILED.md: ${err.message}`);
   }
+
+  // C3: Auto-disable schedule on mission-failed
+  try {
+    const { readState, writeState } = await import("../../../copilot/state.js");
+    const state = readState(".");
+    state.status["mission-failed"] = true;
+    state.status["mission-failed-reason"] = metricDetail.substring(0, 500);
+    state.schedule["auto-disabled"] = true;
+    state.schedule["auto-disabled-reason"] = "mission-failed";
+    writeState(".", state);
+    core.info("State updated: mission-failed, schedule auto-disabled");
+  } catch (err) {
+    core.warning(`Could not update state for mission-failed: ${err.message}`);
+  }
+
+  // C3: Dispatch schedule change to weekly
+  try {
+    await octokit.rest.actions.createWorkflowDispatch({
+      ...repo,
+      workflow_id: "agentic-lib-schedule.yml",
+      ref: "main",
+      inputs: { frequency: "weekly" },
+    });
+    core.info("Dispatched schedule change to weekly after mission-failed");
+  } catch (err) {
+    core.warning(`Could not dispatch schedule change: ${err.message}`);
+  }
 }
 
 /**
@@ -261,10 +299,13 @@ export async function direct(context) {
 
   // --- Gather context (similar to supervisor but focused on metrics) ---
   const mission = readOptionalFile(config.paths.mission.path);
-  const intentionLogFull = readOptionalFile(config.intentionBot.intentionFilepath);
-
-  const costMatches = intentionLogFull.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
-  const cumulativeTransformationCost = [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+  // C2: Read cumulative cost from persistent state
+  let cumulativeTransformationCost = 0;
+  try {
+    const { readState } = await import("../../../copilot/state.js");
+    const state = readState(".");
+    cumulativeTransformationCost = state.counters["cumulative-transforms"] || 0;
+  } catch { /* state not available yet */ }
 
   const missionComplete = existsSync("MISSION_COMPLETE.md");
   const missionFailed = existsSync("MISSION_FAILED.md");
@@ -451,7 +492,7 @@ export async function direct(context) {
     outcome = "directed";
   } else if (decision === "mission-failed") {
     if (process.env.GITHUB_REPOSITORY !== "xn-intenton-z2a/agentic-lib") {
-      await executeMissionFailed(octokit, repo, reason);
+      await executeMissionFailed(octokit, repo, reason, metricAssessment);
       outcome = "mission-failed";
     }
   }

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

@@ -58,6 +58,8 @@ export async function maintainFeatures(context) {
     return { outcome: "wip-limit-reached", details: `Maintenance WIP limit reached (${wipCheck.count}/${config.maintenanceIssuesWipLimit})` };
   }
 
+  const maxTokens = config.maxTokensPerMaintain || 200000;
+
   const mission = readOptionalFile(config.paths.mission.path);
   const featureLimit = config.paths.features.limit;
   const featureFiles = buildFileListing(config.paths.features.path, ".md");
@@ -89,6 +91,7 @@ export async function maintainFeatures(context) {
     "## Constraints",
     `- Maximum ${featureLimit} feature files`,
     "- Feature files must be markdown with a descriptive filename (e.g. HTTP_SERVER.md)",
+    `- Token budget: ~${maxTokens} tokens. Be concise — avoid verbose explanations or unnecessary tool calls.`,
   ].join("\n");
 
   const systemPrompt =
@@ -103,6 +106,9 @@ export async function maintainFeatures(context) {
   if (logFilePath) attachments.push({ type: "file", path: logFilePath });
   if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
 
+  // Derive a tool-call cap from the token budget (rough: ~5000 tokens per tool call)
+  const maxToolCalls = Math.max(10, Math.floor(maxTokens / 5000));
+
   const result = await runCopilotSession({
     workspacePath: process.cwd(),
     model,
@@ -112,6 +118,7 @@ export async function maintainFeatures(context) {
     writablePaths,
     createTools,
     attachments,
+    maxToolCalls,
     excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment", "run_tests"],
     logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });

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

@@ -51,6 +51,8 @@ export async function maintainLibrary(context) {
     return { outcome: "nop", details: "Mission already complete (MISSION_COMPLETE.md signal)" };
   }
 
+  const maxTokens = config.maxTokensPerMaintain || 200000;
+
   const sourcesPath = config.paths.librarySources.path;
   const sources = readOptionalFile(sourcesPath);
   const mission = readOptionalFile(config.paths.mission.path);
@@ -83,6 +85,9 @@ export async function maintainLibrary(context) {
       `Write the URLs as a markdown list in ${sourcesPath}, keeping the existing header text.`,
       "",
       formatPathsSection(writablePaths, config.readOnlyPaths, config),
+      "",
+      "## Constraints",
+      `- Token budget: ~${maxTokens} tokens. Be concise — avoid verbose explanations or unnecessary tool calls.`,
     ].join("\n");
   } else {
     prompt = [
@@ -105,6 +110,7 @@ export async function maintainLibrary(context) {
       "",
       "## Constraints",
       `- Maximum ${libraryLimit} library documents`,
+      `- Token budget: ~${maxTokens} tokens. Be concise — avoid verbose explanations or unnecessary tool calls.`,
     ].join("\n");
   }
 
@@ -116,6 +122,9 @@ export async function maintainLibrary(context) {
   if (logFilePath) attachments.push({ type: "file", path: logFilePath });
   if (screenshotFilePath) attachments.push({ type: "file", path: screenshotFilePath });
 
+  // Derive a tool-call cap from the token budget (rough: ~5000 tokens per tool call)
+  const maxToolCalls = Math.max(10, Math.floor(maxTokens / 5000));
+
   const result = await runCopilotSession({
     workspacePath: process.cwd(),
     model,
@@ -124,6 +133,7 @@ export async function maintainLibrary(context) {
     userPrompt: prompt,
     writablePaths,
     attachments,
+    maxToolCalls,
     excludedTools: ["dispatch_workflow", "close_issue", "label_issue", "post_discussion_comment", "run_tests"],
     logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
   });

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

@@ -106,12 +106,20 @@ async function postDirectReply(octokit, repo, nodeId, body) {
 
 async function gatherContext(octokit, repo, config, t) {
   const mission = readOptionalFile(config.paths.mission.path);
-  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);
+  // Read recent activity from agent-log files
+  let recentActivity = "";
+  let cumulativeTransformationCost = 0;
+  try {
+    const { readdirSync } = await import("fs");
+    const logFiles = readdirSync(".").filter(f => f.startsWith("agent-log-") && f.endsWith(".md")).sort();
+    const recent = logFiles.slice(-5);
+    recentActivity = recent.map(f => readOptionalFile(f)).join("\n---\n").split("\n").slice(-40).join("\n");
+    for (const f of logFiles) {
+      const content = readOptionalFile(f);
+      const costMatches = content.matchAll(/\*\*agentic-lib transformation cost:\*\* (\d+)/g);
+      cumulativeTransformationCost += [...costMatches].reduce((sum, m) => sum + parseInt(m[1], 10), 0);
+    }
+  } catch { /* no agent-log files yet */ }
 
   // Check mission-complete signal
   const missionComplete = existsSync("MISSION_COMPLETE.md");

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

@@ -6,7 +6,7 @@
 // instead of having all context front-loaded into the prompt.
 
 import * as core from "@actions/core";
-import { existsSync, readdirSync, statSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { join, resolve } from "path";
 import { readOptionalFile, formatPathsSection, extractNarrative, NARRATIVE_INSTRUCTION } from "../copilot.js";
 import { runCopilotSession } from "../../../copilot/copilot-session.js";
@@ -38,6 +38,35 @@ function buildFileListing(dirPath, extensions) {
   }
 }
 
+/**
+ * Build a library index: filename + first 2 lines of each library doc, capped at 2000 chars.
+ */
+function buildLibraryIndex(libraryPath) {
+  if (!libraryPath || !existsSync(libraryPath)) return "";
+  try {
+    const files = readdirSync(libraryPath).filter((f) => f.endsWith(".md")).sort();
+    if (files.length === 0) return "";
+    const entries = [];
+    let totalLen = 0;
+    for (const f of files) {
+      const fullPath = join(libraryPath, f);
+      try {
+        const content = readFileSync(fullPath, "utf8");
+        const lines = content.split("\n").slice(0, 2).join(" ").trim();
+        const entry = `- ${f}: ${lines}`;
+        if (totalLen + entry.length > 2000) break;
+        entries.push(entry);
+        totalLen += entry.length;
+      } catch {
+        entries.push(`- ${f}: (unreadable)`);
+      }
+    }
+    return entries.join("\n");
+  } catch {
+    return "";
+  }
+}
+
 /**
  * Run the full transformation pipeline from mission to code.
  *
@@ -89,6 +118,7 @@ export async function transform(context) {
   const testFiles = buildFileListing(config.paths.tests.path, [".js", ".ts"]);
   const webFiles = buildFileListing(config.paths.web?.path || "src/web/", [".html", ".css", ".js"]);
   const featureFiles = buildFileListing(config.paths.features.path, [".md"]);
+  const libraryIndex = buildLibraryIndex(config.paths.library?.path || "library/");
 
   const prompt = [
     "## Instructions",
@@ -107,6 +137,12 @@ export async function transform(context) {
       "The website in `src/web/` uses the JS library. `src/web/lib.js` re-exports from `../lib/main.js`.",
       "When transforming source code, also update the website to use the library's new/changed features.",
     ] : []),
+    ...(libraryIndex ? [
+      "",
+      "## Library Index",
+      "Reference documents available in `library/` (use read_file for full content):",
+      libraryIndex,
+    ] : []),
     "",
     "## Your Task",
     "Analyze the mission and open issues (use list_issues tool).",

package/src/actions/commit-if-changed/action.yml

@@ -29,7 +29,8 @@ runs:
         # Unstage workflow files — GITHUB_TOKEN cannot push workflow changes
         git reset HEAD -- '.github/workflows/' 2>/dev/null || true
         # Unstage log/screenshot files — these live on the agentic-lib-logs branch
-        git reset HEAD -- 'intentïon.md' 'intention.md' 'SCREENSHOT_INDEX.png' 2>/dev/null || true
+        git reset HEAD -- 'intentïon.md' 'SCREENSHOT_INDEX.png' 2>/dev/null || true
+        git reset HEAD -- agent-log-*.md 2>/dev/null || true
         if git diff --cached --quiet; then
           echo "No changes to commit"
         fi

package/src/copilot/config.js

@@ -240,11 +240,10 @@ export function loadConfig(configPath) {
   const bot = toml.bot || {};
 
   // Mission-complete thresholds (with safe defaults)
+  // C6: Removed minDedicatedTests and requireDedicatedTests
   const mc = toml["mission-complete"] || {};
   const missionCompleteThresholds = {
     minResolvedIssues: mc["min-resolved-issues"] ?? 3,
-    minDedicatedTests: mc["min-dedicated-tests"] ?? 1,
-    requireDedicatedTests: mc["require-dedicated-tests"] ?? true,
     maxSourceTodos: mc["max-source-todos"] ?? 0,
   };
 
@@ -261,13 +260,14 @@ export function loadConfig(configPath) {
     transformationBudget: tuning.transformationBudget,
     seeding: toml.seeding || {},
     intentionBot: {
-      intentionFilepath: bot["log-file"] || "intentïon.md",
+      logPrefix: bot["log-prefix"] || "agent-log-",
       logBranch: bot["log-branch"] || "agentic-lib-logs",
       screenshotFile: bot["screenshot-file"] || "SCREENSHOT_INDEX.png",
     },
     init: toml.init || null,
     tdd: toml.tdd === true,
     missionCompleteThresholds,
+    maxTokensPerMaintain: resolvedLimits.maxTokensPerMaintain || 200000,
     writablePaths,
     readOnlyPaths,
     configToml: rawToml,

package/src/copilot/guards.js

@@ -6,10 +6,10 @@
 // (transform.js, fix-code.js, maintain-features.js, maintain-library.js)
 // before Phase 4 convergence replaced them with unconditional runCopilotSession().
 
-import { existsSync } from "fs";
+import { existsSync, readdirSync, readFileSync } from "fs";
 import { resolve } from "path";
 import { execSync } from "child_process";
-import { readCumulativeCost } from "./telemetry.js";
+import { readState } from "./state.js";
 
 /**
  * Task-to-guard mapping. Each task has an ordered list of guards.
@@ -71,9 +71,9 @@ export function checkGuards(taskName, config, workspacePath, { logger } = {}) {
       case "budget-exhausted": {
         const budget = config.transformationBudget || 0;
         if (budget > 0) {
-          const intentionFilepath = config.intentionBot?.intentionFilepath;
-          const filePath = intentionFilepath ? resolve(wsPath, intentionFilepath) : null;
-          const cumulativeCost = readCumulativeCost(filePath);
+          // C2: Read cumulative cost from persistent state (agentic-lib-state.toml)
+          const state = readState(wsPath);
+          const cumulativeCost = state.budget["transformation-budget-used"] || 0;
           if (cumulativeCost >= budget) {
             return { skip: true, reason: `Transformation budget exhausted (${cumulativeCost}/${budget})` };
           }