@xn-intenton-z2a/agentic-lib 7.1.55 → 7.1.56

package/agentic-lib.toml

@@ -7,7 +7,6 @@
 
 [schedule]
 supervisor = "daily"              # off | weekly | daily | hourly | continuous
-model = "gpt-5-mini"              # gpt-5-mini | claude-sonnet-4 | gpt-4.1
 
 [paths]
 mission = "test/MISSION.md"                     #@dist "MISSION.md"
@@ -35,5 +34,20 @@ attempts-per-issue = 2
 features-limit = 2
 library-limit = 32
 
+[tuning]
+# Profile sets defaults for all tuning knobs: min | recommended | max
+# min = fast & cheap (CI testing), recommended = balanced, max = thorough
+profile = "min"                                  #@dist "recommended"
+model = "gpt-5-mini"              # gpt-5-mini | claude-sonnet-4 | gpt-4.1
+# Override individual knobs below. Omit or comment out to use profile defaults.
+# reasoning-effort = "low"       # low | medium | high | xhigh
+infinite-sessions = false        # set to true for long sessions with compaction
+# features-scan = 3              # feature files to include in prompts
+# source-scan = 3                # source files to include
+# source-content = 1000          # max chars per source file
+# issues-scan = 5                # open issues to include
+# document-summary = 500         # max chars for document summaries
+# discussion-comments = 5        # discussion comments to include
+
 [bot]
 log-file = "test/intentïon.md"                  #@dist "intentïon.md"

package/package.json

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

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

@@ -60,6 +60,40 @@ const LIMIT_DEFAULTS = {
   library: 32,
 };
 
+// Tuning profiles: min (fast/cheap), recommended (balanced), max (thorough)
+const TUNING_PROFILES = {
+  min: {
+    reasoningEffort: "low",
+    infiniteSessions: false,
+    featuresScan: 3,
+    sourceScan: 3,
+    sourceContent: 1000,
+    issuesScan: 5,
+    documentSummary: 500,
+    discussionComments: 5,
+  },
+  recommended: {
+    reasoningEffort: "medium",
+    infiniteSessions: true,
+    featuresScan: 10,
+    sourceScan: 10,
+    sourceContent: 5000,
+    issuesScan: 20,
+    documentSummary: 2000,
+    discussionComments: 10,
+  },
+  max: {
+    reasoningEffort: "high",
+    infiniteSessions: true,
+    featuresScan: 50,
+    sourceScan: 50,
+    sourceContent: 20000,
+    issuesScan: 100,
+    documentSummary: 10000,
+    discussionComments: 25,
+  },
+};
+
 /**
  * Read package.json from the project root, returning empty string if not found.
  * @param {string} tomlPath - Path to the TOML config (used to derive project root)
@@ -76,6 +110,33 @@ function readPackageJson(tomlPath, depsRelPath) {
   }
 }
 
+/**
+ * Resolve tuning configuration: start from profile defaults, apply explicit overrides.
+ */
+function resolveTuning(tuningSection) {
+  const profileName = tuningSection.profile || "recommended";
+  const profile = TUNING_PROFILES[profileName] || TUNING_PROFILES.recommended;
+  const tuning = { ...profile };
+
+  if (tuningSection["reasoning-effort"]) tuning.reasoningEffort = tuningSection["reasoning-effort"];
+  if (tuningSection["infinite-sessions"] === true || tuningSection["infinite-sessions"] === false) {
+    tuning.infiniteSessions = tuningSection["infinite-sessions"];
+  }
+  const numericOverrides = {
+    "features-scan": "featuresScan",
+    "source-scan": "sourceScan",
+    "source-content": "sourceContent",
+    "issues-scan": "issuesScan",
+    "document-summary": "documentSummary",
+    "discussion-comments": "discussionComments",
+  };
+  for (const [tomlKey, jsKey] of Object.entries(numericOverrides)) {
+    if (tuningSection[tomlKey] > 0) tuning[jsKey] = tuningSection[tomlKey];
+  }
+
+  return tuning;
+}
+
 /**
  * Load configuration from agentic-lib.toml.
  *
@@ -132,12 +193,15 @@ export function loadConfig(configPath) {
   paths.features.limit = limits["features-limit"] || LIMIT_DEFAULTS.features;
   paths.library.limit = limits["library-limit"] || LIMIT_DEFAULTS.library;
 
+  const tuning = resolveTuning(toml.tuning || {});
+
   const execution = toml.execution || {};
   const bot = toml.bot || {};
 
   return {
     supervisor: toml.schedule?.supervisor || "daily",
-    model: toml.schedule?.model || "gpt-5-mini",
+    model: toml.tuning?.model || toml.schedule?.model || "gpt-5-mini",
+    tuning,
     paths,
     buildScript: execution.build || "npm run build",
     testScript: execution.test || "npm test",

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

@@ -48,11 +48,12 @@ export function buildClientOptions(githubToken) {
  * @param {string} options.prompt - The prompt to send
  * @param {string[]} options.writablePaths - Paths the agent may modify
  * @param {string} [options.githubToken] - Optional token; falls back to COPILOT_GITHUB_TOKEN env var.
+ * @param {Object} [options.tuning] - Tuning config (reasoningEffort, infiniteSessions)
  * @returns {Promise<{content: string, tokensUsed: number}>}
  */
-export async function runCopilotTask({ model, systemMessage, prompt, writablePaths, githubToken }) {
+export async function runCopilotTask({ model, systemMessage, prompt, writablePaths, githubToken, tuning }) {
   core.info(
-    `[copilot] Creating client (model=${model}, promptLen=${prompt.length}, writablePaths=${writablePaths.length})`,
+    `[copilot] Creating client (model=${model}, promptLen=${prompt.length}, writablePaths=${writablePaths.length}, tuning=${tuning?.reasoningEffort || "default"})`,
   );
 
   const clientOptions = buildClientOptions(githubToken);
@@ -60,13 +61,20 @@ export async function runCopilotTask({ model, systemMessage, prompt, writablePat
 
   try {
     core.info("[copilot] Creating session...");
-    const session = await client.createSession({
+    const sessionConfig = {
       model,
       systemMessage: { content: systemMessage },
       tools: createAgentTools(writablePaths),
       onPermissionRequest: approveAll,
       workingDirectory: process.cwd(),
-    });
+    };
+    if (tuning?.reasoningEffort) {
+      sessionConfig.reasoningEffort = tuning.reasoningEffort;
+    }
+    if (tuning?.infiniteSessions === true) {
+      sessionConfig.infiniteSessions = {};
+    }
+    const session = await client.createSession(sessionConfig);
     core.info(`[copilot] Session created: ${session.sessionId}`);
 
     // Check auth status now that client is connected

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

@@ -11,7 +11,7 @@ import { runCopilotTask, readOptionalFile, scanDirectory } from "../copilot.js";
 
 const BOT_LOGINS = ["github-actions[bot]", "github-actions"];
 
-async function fetchDiscussion(octokit, discussionUrl) {
+async function fetchDiscussion(octokit, discussionUrl, commentsLimit = 10) {
   const urlMatch = discussionUrl.match(/github\.com\/([^/]+)\/([^/]+)\/discussions\/(\d+)/);
   if (!urlMatch) {
     core.warning(`Could not parse discussion URL: ${discussionUrl}`);
@@ -26,7 +26,7 @@ async function fetchDiscussion(octokit, discussionUrl) {
           id
           title
           body
-          comments(last: 10) {
+          comments(last: ${commentsLimit}) {
             nodes {
               body
               author { login }
@@ -53,7 +53,7 @@ async function fetchDiscussion(octokit, discussionUrl) {
   }
 }
 
-function buildPrompt(discussionUrl, discussion, context) {
+function buildPrompt(discussionUrl, discussion, context, t) {
   const { config, instructions } = context;
   const { title, body, comments } = discussion;
 
@@ -63,7 +63,7 @@ function buildPrompt(discussionUrl, discussion, context) {
   const lastBotReply = botReplies.length > 0 ? botReplies[botReplies.length - 1] : null;
 
   const mission = readOptionalFile(config.paths.mission.path);
-  const contributing = readOptionalFile(config.paths.contributing.path, 1000);
+  const contributing = readOptionalFile(config.paths.contributing.path, t.documentSummary || 1000);
   const featuresPath = config.paths.features.path;
   const featureNames = existsSync(featuresPath)
     ? scanDirectory(featuresPath, ".md").map((f) => f.name.replace(".md", ""))
@@ -152,20 +152,21 @@ async function postReply(octokit, nodeId, replyBody) {
  */
 export async function discussions(context) {
   const { octokit, model, discussionUrl } = context;
+  const t = context.config?.tuning || {};
 
   if (!discussionUrl) {
     throw new Error("discussions task requires discussion-url input");
   }
 
-  const discussion = await fetchDiscussion(octokit, discussionUrl);
-  const prompt = buildPrompt(discussionUrl, discussion, context);
-
+  const discussion = await fetchDiscussion(octokit, discussionUrl, t.discussionComments || 10);
+  const prompt = buildPrompt(discussionUrl, discussion, context, t);
   const { content, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
     model,
     systemMessage:
       "You are this repository. Respond in first person. Be concise and engaging — never repeat what you said in your last reply. Adapt to the user's language level. Encourage experimentation and suggest interesting projects. When a user requests an action, pass it to the supervisor via [ACTION:request-supervisor]. Protect the mission: push back on requests that contradict it.",
     prompt,
     writablePaths: [],
+    tuning: t,
   });
 
   const actionMatch = content.match(/\[ACTION:(\S+?)\](.+)?/);

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

@@ -13,7 +13,7 @@ import { runCopilotTask, readOptionalFile, scanDirectory } from "../copilot.js";
 /**
  * Enhance a single GitHub issue with testable acceptance criteria.
  */
-async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model }) {
+async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t }) {
   if (await isIssueResolved(octokit, repo, issueNumber)) {
     return { outcome: "nop", details: `Issue #${issueNumber} already resolved` };
   }
@@ -28,7 +28,7 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
   }
 
   const contributing = readOptionalFile(config.paths.contributing.path);
-  const features = scanDirectory(config.paths.features.path, ".md", { contentLimit: 2000 });
+  const features = scanDirectory(config.paths.features.path, ".md", { contentLimit: t.documentSummary || 2000 });
 
   const agentInstructions = instructions || "Enhance this issue with clear, testable acceptance criteria.";
 
@@ -39,7 +39,7 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
     `## Issue #${issueNumber}: ${issue.title}`,
     issue.body || "(no description)",
     "",
-    contributing ? `## Contributing Guidelines\n${contributing.substring(0, 1000)}` : "",
+    contributing ? `## Contributing Guidelines\n${contributing.substring(0, t.documentSummary || 2000)}` : "",
     features.length > 0 ? `## Related Features\n${features.map((f) => f.content).join("\n---\n")}` : "",
     config.configToml ? `## Configuration (agentic-lib.toml)\n\`\`\`toml\n${config.configToml}\n\`\`\`` : "",
     config.packageJson ? `## Dependencies (package.json)\n\`\`\`json\n${config.packageJson}\n\`\`\`` : "",
@@ -64,6 +64,7 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
     systemMessage: "You are a requirements analyst. Enhance GitHub issues with clear, testable acceptance criteria.",
     prompt,
     writablePaths: [],
+    tuning: t,
   });
 
   if (enhancedBody.trim()) {
@@ -113,10 +114,11 @@ async function enhanceSingleIssue({ octokit, repo, config, issueNumber, instruct
  */
 export async function enhanceIssue(context) {
   const { octokit, repo, config, issueNumber, instructions, model } = context;
+  const t = config.tuning || {};
 
   // Single issue mode
   if (issueNumber) {
-    return enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model });
+    return enhanceSingleIssue({ octokit, repo, config, issueNumber, instructions, model, tuning: t });
   }
 
   // Batch mode: find up to 3 unready automated issues
@@ -149,6 +151,7 @@ export async function enhanceIssue(context) {
       issueNumber: issue.number,
       instructions,
       model,
+      tuning: t,
     });
     results.push(result);
     totalTokens += result.tokensUsed || 0;

package/src/actions/agentic-step/tasks/fix-code.js

@@ -93,11 +93,13 @@ export async function fixCode(context) {
     "- Make minimal changes to fix the failing tests",
   ].join("\n");
 
+  const t = config.tuning || {};
   const { tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
     model,
     systemMessage: `You are an autonomous coding agent fixing failing tests on PR #${prNumber}. Make minimal, targeted changes to fix the test failures.`,
     prompt,
     writablePaths,
+    tuning: t,
   });
 
   core.info(`Copilot SDK fix response received (${tokensUsed} tokens)`);

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

@@ -15,19 +15,20 @@ import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection } f
  */
 export async function maintainFeatures(context) {
   const { config, instructions, writablePaths, model, octokit, repo } = context;
+  const t = config.tuning || {};
 
   const mission = readOptionalFile(config.paths.mission.path);
   const featuresPath = config.paths.features.path;
   const featureLimit = config.paths.features.limit;
-  const features = scanDirectory(featuresPath, ".md");
+  const features = scanDirectory(featuresPath, ".md", { fileLimit: t.featuresScan || 10 });
   const libraryDocs = scanDirectory(config.paths.library.path, ".md", {
-    contentLimit: 1000,
+    contentLimit: t.documentSummary || 1000,
   });
 
   const { data: closedIssues } = await octokit.rest.issues.listForRepo({
     ...repo,
     state: "closed",
-    per_page: 20,
+    per_page: t.issuesScan || 20,
     sort: "updated",
     direction: "desc",
   });
@@ -48,7 +49,7 @@ export async function maintainFeatures(context) {
     ...libraryDocs.map((d) => `### ${d.name}\n${d.content}`),
     "",
     `## Recently Closed Issues (${closedIssues.length})`,
-    ...closedIssues.slice(0, 10).map((i) => `- #${i.number}: ${i.title}`),
+    ...closedIssues.slice(0, Math.floor((t.issuesScan || 20) / 2)).map((i) => `- #${i.number}: ${i.title}`),
     "",
     "## Your Task",
     `1. Review each existing feature — if it is already implemented or irrelevant, delete it.`,
@@ -68,6 +69,7 @@ export async function maintainFeatures(context) {
       "You are a feature lifecycle manager. Create, update, and prune feature specification files to keep the project focused on its mission.",
     prompt,
     writablePaths,
+    tuning: t,
   });
 
   return {

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

@@ -16,6 +16,7 @@ import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection } f
  */
 export async function maintainLibrary(context) {
   const { config, instructions, writablePaths, model } = context;
+  const t = config.tuning || {};
 
   const sources = readOptionalFile(config.paths.librarySources.path);
   if (!sources.trim()) {
@@ -25,7 +26,7 @@ export async function maintainLibrary(context) {
 
   const libraryPath = config.paths.library.path;
   const libraryLimit = config.paths.library.limit;
-  const libraryDocs = scanDirectory(libraryPath, ".md", { contentLimit: 500 });
+  const libraryDocs = scanDirectory(libraryPath, ".md", { contentLimit: t.documentSummary || 500 });
 
   const agentInstructions = instructions || "Maintain the library by updating documents from sources.";
 
@@ -56,6 +57,7 @@ export async function maintainLibrary(context) {
       "You are a knowledge librarian. Maintain a library of technical documents extracted from web sources.",
     prompt,
     writablePaths,
+    tuning: t,
   });
 
   return {

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

@@ -78,11 +78,13 @@ export async function resolveIssue(context) {
     contributing ? `\n## Contributing Guidelines\n${contributing}` : "",
   ].join("\n");
 
+  const t = config.tuning || {};
   const { content: resultContent, tokensUsed, inputTokens, outputTokens, cost } = await runCopilotTask({
     model,
     systemMessage: `You are an autonomous coding agent resolving GitHub issue #${issueNumber}. Write clean, tested code. Only modify files listed under "Writable" paths. Read-only paths are for context only.`,
     prompt,
     writablePaths,
+    tuning: t,
   });
 
   core.info(`Copilot SDK response received (${tokensUsed} tokens)`);

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

@@ -21,7 +21,7 @@ import { runCopilotTask, scanDirectory } from "../copilot.js";
  * @param {string} params.model - Model name
  * @returns {Promise<Object>} Result with outcome, tokensUsed, model
  */
-async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, instructions, model }) {
+async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, instructions, model, tuning: t }) {
   const { data: issue } = await octokit.rest.issues.get({
     ...repo,
     issue_number: Number(targetIssueNumber),
@@ -32,18 +32,18 @@ async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, ins
   }
 
   const sourceFiles = scanDirectory(config.paths.source.path, [".js", ".ts"], {
-    contentLimit: 5000,
-    fileLimit: 20,
+    contentLimit: t.sourceContent || 5000,
+    fileLimit: t.sourceScan || 20,
     recursive: true,
   });
   const testFiles = scanDirectory(config.paths.tests.path, [".test.js", ".test.ts"], {
-    contentLimit: 5000,
-    fileLimit: 20,
+    contentLimit: t.sourceContent || 5000,
+    fileLimit: t.sourceScan || 20,
     recursive: true,
   });
   const docsFiles = scanDirectory(config.paths.documentation?.path || "docs/", [".md"], {
-    fileLimit: 10,
-    contentLimit: 2000,
+    fileLimit: t.featuresScan || 10,
+    contentLimit: t.documentSummary || 2000,
   });
 
   const agentInstructions = instructions || "Review whether this issue has been resolved by the current codebase.";
@@ -85,6 +85,7 @@ async function reviewSingleIssue({ octokit, repo, config, targetIssueNumber, ins
     systemMessage: "You are a code reviewer determining if GitHub issues have been resolved.",
     prompt,
     writablePaths: [],
+    tuning: t,
   });
 
   // Strip leading markdown formatting (e.g., **RESOLVED** or *RESOLVED*)
@@ -184,10 +185,11 @@ async function findUnreviewedIssues(octokit, repo, limit) {
  */
 export async function reviewIssue(context) {
   const { octokit, repo, config, issueNumber, instructions, model } = context;
+  const t = config.tuning || {};
 
   // Single issue mode
   if (issueNumber) {
-    return reviewSingleIssue({ octokit, repo, config, targetIssueNumber: issueNumber, instructions, model });
+    return reviewSingleIssue({ octokit, repo, config, targetIssueNumber: issueNumber, instructions, model, tuning: t });
   }
 
   // Batch mode: find up to 3 unreviewed issues
@@ -204,7 +206,9 @@ export async function reviewIssue(context) {
 
   for (const num of issueNumbers) {
     core.info(`Batch reviewing issue #${num} (${results.length + 1}/${issueNumbers.length})`);
-    const result = await reviewSingleIssue({ octokit, repo, config, targetIssueNumber: num, instructions, model });
+    const result = await reviewSingleIssue({
+      octokit, repo, config, targetIssueNumber: num, instructions, model, tuning: t,
+    });
     results.push(result);
     totalTokens += result.tokensUsed || 0;
     totalInputTokens += result.inputTokens || 0;

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

@@ -9,7 +9,7 @@ import * as core from "@actions/core";
 import { existsSync } from "fs";
 import { runCopilotTask, readOptionalFile, scanDirectory } from "../copilot.js";
 
-async function gatherContext(octokit, repo, config) {
+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");
 
@@ -28,7 +28,7 @@ async function gatherContext(octokit, repo, config) {
   const { data: openIssues } = await octokit.rest.issues.listForRepo({
     ...repo,
     state: "open",
-    per_page: 20,
+    per_page: t.issuesScan || 20,
     sort: "created",
     direction: "asc",
   });
@@ -305,8 +305,9 @@ async function executeAction(octokit, repo, action, params) {
  */
 export async function supervise(context) {
   const { octokit, repo, config, instructions, model } = context;
+  const t = config.tuning || {};
 
-  const ctx = await gatherContext(octokit, repo, config);
+  const ctx = await gatherContext(octokit, repo, config, t);
   const agentInstructions = instructions || "You are the supervisor. Decide what actions to take.";
   const prompt = buildPrompt(ctx, agentInstructions);
 
@@ -316,6 +317,7 @@ export async function supervise(context) {
       "You are the supervisor of an autonomous coding repository. Your job is to advance the mission by choosing which workflows to dispatch and which GitHub actions to take. Pick multiple actions when appropriate. Be strategic — consider what's already in progress, what's blocked, and what will make the most impact.",
     prompt,
     writablePaths: [],
+    tuning: t,
   });
 
   const actions = parseActions(content);

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

@@ -16,6 +16,7 @@ import { runCopilotTask, readOptionalFile, scanDirectory, formatPathsSection } f
  */
 export async function transform(context) {
   const { config, instructions, writablePaths, testCommand, model, octokit, repo, issueNumber } = context;
+  const t = config.tuning || {};
 
   // Read mission (required)
   const mission = readOptionalFile(config.paths.mission.path);
@@ -24,16 +25,17 @@ export async function transform(context) {
     return { outcome: "nop", details: "No mission file found" };
   }
 
-  const features = scanDirectory(config.paths.features.path, ".md");
+  const features = scanDirectory(config.paths.features.path, ".md", { fileLimit: t.featuresScan || 10 });
   const sourceFiles = scanDirectory(config.paths.source.path, [".js", ".ts"], {
-    contentLimit: 5000,
+    fileLimit: t.sourceScan || 10,
+    contentLimit: t.sourceContent || 5000,
     recursive: true,
   });
 
   const { data: openIssues } = await octokit.rest.issues.listForRepo({
     ...repo,
     state: "open",
-    per_page: 20,
+    per_page: t.issuesScan || 20,
   });
 
   // Fetch target issue if specified
@@ -67,6 +69,7 @@ export async function transform(context) {
       features,
       sourceFiles,
       openIssues,
+      tuning: t,
     });
   }
 
@@ -88,13 +91,13 @@ export async function transform(context) {
     mission,
     "",
     `## Current Features (${features.length})`,
-    ...features.map((f) => `### ${f.name}\n${f.content.substring(0, 2000)}`),
+    ...features.map((f) => `### ${f.name}\n${f.content.substring(0, t.documentSummary || 2000)}`),
     "",
     `## Current Source Files (${sourceFiles.length})`,
     ...sourceFiles.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``),
     "",
     `## Open Issues (${openIssues.length})`,
-    ...openIssues.slice(0, 20).map((i) => `- #${i.number}: ${i.title}`),
+    ...openIssues.slice(0, t.issuesScan || 20).map((i) => `- #${i.number}: ${i.title}`),
     "",
     "## Output Artifacts",
     "If your changes produce output artifacts (plots, visualizations, data files, usage examples),",
@@ -126,6 +129,7 @@ export async function transform(context) {
       "You are an autonomous code transformation agent. Your goal is to advance the repository toward its mission by making the most impactful change possible in a single step.",
     prompt,
     writablePaths,
+    tuning: t,
   });
 
   core.info(`Transformation step completed (${tokensUsed} tokens)`);
@@ -155,6 +159,7 @@ async function transformTdd({
   features,
   sourceFiles,
   openIssues,
+  tuning: t,
 }) {
   let totalTokens = 0;
 
@@ -175,13 +180,13 @@ async function transformTdd({
     mission,
     "",
     `## Current Features (${features.length})`,
-    ...features.map((f) => `### ${f.name}\n${f.content.substring(0, 2000)}`),
+    ...features.map((f) => `### ${f.name}\n${f.content.substring(0, t.documentSummary || 2000)}`),
     "",
     `## Current Source Files (${sourceFiles.length})`,
     ...sourceFiles.map((f) => `### ${f.name}\n\`\`\`\n${f.content}\n\`\`\``),
     "",
     `## Open Issues (${openIssues.length})`,
-    ...openIssues.slice(0, 20).map((i) => `- #${i.number}: ${i.title}`),
+    ...openIssues.slice(0, t.issuesScan || 20).map((i) => `- #${i.number}: ${i.title}`),
     "",
     formatPathsSection(writablePaths, readOnlyPaths, _config),
     "",
@@ -197,6 +202,7 @@ async function transformTdd({
       "You are a TDD agent. In this phase, write ONLY a failing test that captures the next feature requirement. Do not write implementation code.",
     prompt: testPrompt,
     writablePaths,
+    tuning: t,
   });
   totalTokens += phase1.tokensUsed;
   const testResult = phase1.content;
@@ -242,6 +248,7 @@ async function transformTdd({
       "You are a TDD agent. A failing test was written in Phase 1. Write the minimum implementation to make it pass. Do not modify the test.",
     prompt: implPrompt,
     writablePaths,
+    tuning: t,
   });
   totalTokens += phase2.tokensUsed;
 

package/src/seeds/zero-package.json

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