@xn-intenton-z2a/agentic-lib 7.4.4 → 7.4.6

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

@@ -128,7 +128,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Read test command from config
         id: config

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

@@ -126,17 +126,20 @@ permissions: write-all
 
 jobs:
   # Step 1: Update agentic-lib and infrastructure (commits to main)
+  # Skip tests when purge/reseed will replace all user code anyway
   update:
     uses: ./.github/workflows/agentic-lib-update.yml
     with:
       ref: ${{ inputs.ref }}
       dry-run: ${{ inputs.dry-run || 'false' }}
+      skip-tests: ${{ inputs.mode == 'reseed' || inputs.mode == 'purge' }}
     secrets: inherit
 
   # Step 2: Reseed/purge and configure (only if mode != update)
+  # Use !cancelled() so purge runs even if update's npm test failed
   init:
     needs: update
-    if: inputs.mode == 'reseed' || inputs.mode == 'purge'
+    if: "!cancelled() && (inputs.mode == 'reseed' || inputs.mode == 'purge')"
     runs-on: ubuntu-latest
     env:
       INIT_MODE: ${{ inputs.mode }}

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

@@ -22,6 +22,10 @@ on:
         type: string
         required: false
         default: "false"
+      skip-tests:
+        type: string
+        required: false
+        default: "false"
   #@dist schedule:
   #@dist   - cron: "15 6 * * *"
   workflow_dispatch:
@@ -76,7 +80,9 @@ jobs:
         if: hashFiles('src/actions/agentic-step/package.json') != ''
         run: cd src/actions/agentic-step && npm ci
 
-      - run: npm test
+      - name: Run tests
+        if: inputs.skip-tests != 'true'
+        run: npm test
 
       - name: Commit and push to main [skip ci]
         if: github.repository != 'xn-intenton-z2a/agentic-lib' && inputs.dry-run != 'true' && inputs.dry-run != true

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

@@ -601,7 +601,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Apply profile and model to config
         if: inputs.profile != '' || inputs.model != ''
@@ -713,7 +717,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Run director
         id: director
@@ -764,7 +772,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Run supervisor
         if: github.repository != 'xn-intenton-z2a/agentic-lib'
@@ -814,7 +826,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Check mission-complete signal
         id: fix-mission-check
@@ -1128,7 +1144,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Review issues
         uses: ./.github/agentic-lib/actions/agentic-step
@@ -1186,7 +1206,11 @@ jobs:
 
       - name: Install agentic-step dependencies
         working-directory: .github/agentic-lib/actions/agentic-step
-        run: npm ci
+        run: |
+          npm ci
+          if [ -d "../../copilot" ]; then
+            ln -sf "$(pwd)/node_modules" ../../copilot/node_modules
+          fi
 
       - name: Load config
         id: config

package/README.md

@@ -390,8 +390,8 @@ agentic-lib iterate --mission 6-kyu-understand-hamming-distance --model gpt-5-mi
 Target:  /tmp/bench
 Model:   gpt-5-mini
 
-[hybrid] Creating session (model=gpt-5-mini, workspace=/tmp/bench)
-[hybrid] Session: sess_abc123
+[agentic-lib] Creating session (model=gpt-5-mini, workspace=/tmp/bench)
+[agentic-lib] Session: sess_abc123
   [tool] read_file
   [tool] read_file
   [tool] write_file

package/bin/agentic-lib.js

@@ -30,6 +30,12 @@ const flags = args.slice(1);
 
 let initChanges = 0;
 const TASK_COMMANDS = ["transform", "maintain-features", "maintain-library", "fix-code"];
+const TASK_AGENT_MAP = {
+  "transform": "agent-issue-resolution",
+  "fix-code": "agent-apply-fix",
+  "maintain-features": "agent-maintain-features",
+  "maintain-library": "agent-maintain-library",
+};
 const INIT_COMMANDS = ["init", "update", "reset"];
 const ALL_COMMANDS = [...INIT_COMMANDS, ...TASK_COMMANDS, "version", "mcp", "iterate"];
 
@@ -332,7 +338,14 @@ async function runIterate() {
   }
 
   // Build context-aware user prompt
-  const userPrompt = buildUserPrompt(agentName, localContext, githubContext, { tuning: config.tuning });
+  const { prompt: userPrompt } = buildUserPrompt(agentName, localContext, githubContext, {
+    tuning: config.tuning,
+    config,
+  });
+
+  // Derive maxToolCalls from transformation budget
+  const budget = config.transformationBudget || 0;
+  const effectiveMaxToolCalls = budget > 0 ? budget * 20 : undefined;
 
   const result = await runHybridSession({
     workspacePath: target,
@@ -342,6 +355,7 @@ async function runIterate() {
     agentPrompt,
     userPrompt,
     writablePaths: config.writablePaths?.length > 0 ? config.writablePaths : undefined,
+    maxToolCalls: effectiveMaxToolCalls,
   });
 
   console.log("");
@@ -366,84 +380,109 @@ async function runIterate() {
 // ─── Task Runner ─────────────────────────────────────────────────────
 
 async function runTask(taskName) {
+  // Task commands are now aliases for iterate --agent <agent-name>
+  const agentName = TASK_AGENT_MAP[taskName];
+  if (!agentName) {
+    console.error(`Unknown task: ${taskName}`);
+    return 1;
+  }
+
   console.log("");
-  console.log(`=== agentic-lib ${taskName} ===`);
+  console.log(`=== agentic-lib ${taskName} (→ iterate --agent ${agentName}) ===`);
   console.log(`Target:  ${target}`);
   console.log(`Model:   ${model}`);
   console.log(`Dry-run: ${dryRun}`);
   console.log("");
 
-  // Load config from shared module
   const { loadConfig } = await import("../src/copilot/config.js");
-  const config = loadConfig(resolve(target, "agentic-lib.toml"));
-  const effectiveModel = model || config.model;
+  let config;
+  try {
+    config = loadConfig(resolve(target, "agentic-lib.toml"));
+  } catch {
+    config = { tuning: {}, model: "gpt-5-mini", paths: {}, writablePaths: [], readOnlyPaths: [] };
+  }
+  const effectiveModel = model || config.model || "gpt-5-mini";
 
-  console.log(`[config] supervisor=${config.supervisor}`);
-  console.log(`[config] writable=${config.writablePaths.join(", ")}`);
-  console.log(`[config] test=${config.testScript}`);
+  console.log(`[config] writable=${(config.writablePaths || []).join(", ")}`);
   console.log("");
 
+  // Short-circuit guards — skip LLM invocation when unnecessary
+  const { checkGuards } = await import("../src/copilot/guards.js");
+  const guardResult = checkGuards(taskName, config, target);
+  if (guardResult.skip) {
+    console.log(`=== ${taskName} skipped (nop) ===`);
+    console.log(`Reason: ${guardResult.reason}`);
+    console.log("");
+    return 0;
+  }
+
   if (dryRun) {
     console.log("=== DRY RUN — task would run but not sending to Copilot ===");
     return 0;
   }
 
-  // Change to target directory so relative paths in config work
-  const originalCwd = process.cwd();
-  process.chdir(target);
-
   try {
-    const context = {
+    const { loadAgentPrompt } = await import("../src/copilot/agents.js");
+    const { runHybridSession } = await import("../src/copilot/hybrid-session.js");
+    const { gatherLocalContext, gatherGitHubContext, buildUserPrompt } = await import("../src/copilot/context.js");
+
+    const agentPrompt = loadAgentPrompt(agentName);
+    const localContext = gatherLocalContext(target, config);
+
+    let githubContext;
+    if (issueNumber || prNumber) {
+      githubContext = gatherGitHubContext({
+        issueNumber: issueNumber || undefined,
+        prNumber: prNumber || undefined,
+        workspacePath: target,
+      });
+    }
+
+    const { prompt: userPrompt, promptBudget } = buildUserPrompt(agentName, localContext, githubContext, {
+      tuning: config.tuning,
       config,
-      writablePaths: config.writablePaths,
+    });
+
+    // Derive maxToolCalls from transformation budget (budget × 20, or unlimited)
+    const budget = config.transformationBudget || 0;
+    const effectiveMaxToolCalls = budget > 0 ? budget * 20 : undefined;
+
+    const result = await runHybridSession({
+      workspacePath: target,
       model: effectiveModel,
-      testCommand: config.testScript,
-      logger: { info: console.log, warning: console.warn, error: console.error, debug: () => {} },
-    };
-
-    let result;
-    switch (taskName) {
-      case "transform": {
-        const { transform } = await import("../src/copilot/tasks/transform.js");
-        result = await transform(context);
-        break;
-      }
-      case "maintain-features": {
-        const { maintainFeatures } = await import("../src/copilot/tasks/maintain-features.js");
-        result = await maintainFeatures(context);
-        break;
-      }
-      case "maintain-library": {
-        const { maintainLibrary } = await import("../src/copilot/tasks/maintain-library.js");
-        result = await maintainLibrary(context);
-        break;
-      }
-      case "fix-code": {
-        const { fixCode } = await import("../src/copilot/tasks/fix-code.js");
-        result = await fixCode(context);
-        break;
-      }
-      default:
-        console.error(`Unknown task: ${taskName}`);
-        return 1;
-    }
+      tuning: config.tuning || {},
+      timeoutMs,
+      agentPrompt,
+      userPrompt,
+      writablePaths: config.writablePaths?.length > 0 ? config.writablePaths : undefined,
+      maxToolCalls: effectiveMaxToolCalls,
+    });
+
+    // Build enriched result (10e)
+    const outcome = result.success ? "transformed" : "error";
+    const tokensUsed = result.tokensIn + result.tokensOut;
 
     console.log("");
     console.log(`=== ${taskName} completed ===`);
-    console.log(`Outcome: ${result.outcome}`);
-    if (result.details) console.log(`Details: ${result.details}`);
-    if (result.tokensUsed) console.log(`Tokens: ${result.tokensUsed} (in=${result.inputTokens} out=${result.outputTokens})`);
+    console.log(`Outcome:       ${outcome}`);
+    console.log(`Session time:  ${result.sessionTime}s`);
+    console.log(`Tool calls:    ${result.toolCalls}`);
+    console.log(`Tokens:        ${tokensUsed} (in=${result.tokensIn} out=${result.tokensOut})`);
     if (result.narrative) console.log(`Narrative: ${result.narrative}`);
+    if (promptBudget) {
+      console.log("Prompt budget:");
+      for (const entry of promptBudget) {
+        console.log(`  ${entry.section}: ${entry.size} chars, ${entry.files} files ${entry.notes}`);
+      }
+    }
     console.log("");
-    return 0;
+    return result.success ? 0 : 1;
   } catch (err) {
     console.error("");
     console.error(`=== ${taskName} FAILED ===`);
     console.error(err.message);
     if (err.stack) console.error(err.stack);
     return 1;
-  } finally {
-    process.chdir(originalCwd);
   }
 }
 
@@ -1229,6 +1268,7 @@ function runInit() {
 
   initWorkflows();
   initActions(agenticDir);
+  initDirContents("copilot", resolve(agenticDir, "copilot"), "Copilot (shared modules)");
   initDirContents("agents", resolve(agenticDir, "agents"), "Agents");
   initDirContents("seeds", resolve(agenticDir, "seeds"), "Seeds");
   initScripts(agenticDir);

package/package.json

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

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

@@ -1,308 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 // Copyright (C) 2025-2026 Polycode Limited
-// config-loader.js — Parse agentic-lib.toml and resolve paths
+// config-loader.js — Thin re-export from shared src/copilot/config.js
 //
-// TOML-only configuration. The config file is required.
-// All defaults are defined here in one place.
+// Phase 4: Configuration logic now lives in src/copilot/config.js.
+// This file re-exports for backwards compatibility with existing imports.
 
-import { readFileSync, existsSync } from "fs";
-import { dirname, join } from "path";
-import { parse as parseToml } from "smol-toml";
-
-/**
- * @typedef {Object} PathConfig
- * @property {string} path - The filesystem path
- * @property {string[]} permissions - Access permissions (e.g. ['write'])
- * @property {number} [limit] - Maximum number of files allowed
- */
-
-/**
- * @typedef {Object} AgenticConfig
- * @property {string} schedule - Schedule identifier
- * @property {string} supervisor - Supervisor frequency (off | weekly | daily | hourly | continuous)
- * @property {string} model - Copilot SDK model for LLM requests
- * @property {Object<string, PathConfig>} paths - Mapped paths with permissions
- * @property {string} testScript - Self-contained test command (e.g. "npm ci && npm test")
- * @property {number} featureDevelopmentIssuesWipLimit - Max concurrent feature issues
- * @property {number} maintenanceIssuesWipLimit - Max concurrent maintenance issues
- * @property {number} attemptsPerBranch - Max attempts per branch
- * @property {number} attemptsPerIssue - Max attempts per issue
- * @property {Object} seeding - Seed file configuration
- * @property {Object} intentionBot - Bot configuration
- * @property {boolean} tdd - Whether TDD mode is enabled
- * @property {string[]} writablePaths - All paths with write permission
- * @property {string[]} readOnlyPaths - All paths without write permission
- */
-
-// Keys whose paths are writable by agents
-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/",
-  readme: "README.md",
-  dependencies: "package.json",
-  library: "library/",
-  librarySources: "SOURCES.md",
-  contributing: "CONTRIBUTING.md",
-  web: "src/web/",
-};
-
-// Default limits for path-specific constraints
-const LIMIT_DEFAULTS = {
-  features: 4,
-  library: 32,
-};
-
-// Fallback profile defaults — used only when [profiles.*] is missing from TOML.
-// The canonical source of truth is the [profiles.*] sections in agentic-lib.toml.
-const FALLBACK_TUNING = {
-  reasoningEffort: "medium",
-  infiniteSessions: true,
-  transformationBudget: 32,
-  featuresScan: 10,
-  sourceScan: 10,
-  sourceContent: 5000,
-  testContent: 3000,
-  issuesScan: 20,
-  issueBodyLimit: 500,
-  staleDays: 30,
-  documentSummary: 2000,
-  discussionComments: 10,
-};
-
-const FALLBACK_LIMITS = {
-  featureIssues: 2,
-  maintenanceIssues: 1,
-  attemptsPerBranch: 3,
-  attemptsPerIssue: 2,
-  featuresLimit: 4,
-  libraryLimit: 32,
-};
-
-/**
- * Parse a TOML profile section into tuning defaults (camelCase keys).
- */
-function parseTuningProfile(profileSection) {
-  if (!profileSection) return null;
-  return {
-    reasoningEffort: profileSection["reasoning-effort"] || "medium",
-    infiniteSessions: profileSection["infinite-sessions"] ?? true,
-    transformationBudget: profileSection["transformation-budget"] || 32,
-    featuresScan: profileSection["max-feature-files"] || 10,
-    sourceScan: profileSection["max-source-files"] || 10,
-    sourceContent: profileSection["max-source-chars"] || 5000,
-    testContent: profileSection["max-test-chars"] || 3000,
-    issuesScan: profileSection["max-issues"] || 20,
-    issueBodyLimit: profileSection["issue-body-limit"] || 500,
-    staleDays: profileSection["stale-days"] || 30,
-    documentSummary: profileSection["max-summary-chars"] || 2000,
-    discussionComments: profileSection["max-discussion-comments"] || 10,
-  };
-}
-
-/**
- * Parse a TOML profile section into limits defaults (camelCase keys).
- */
-function parseLimitsProfile(profileSection) {
-  if (!profileSection) return null;
-  return {
-    featureIssues: profileSection["max-feature-issues"] || 2,
-    maintenanceIssues: profileSection["max-maintenance-issues"] || 1,
-    attemptsPerBranch: profileSection["max-attempts-per-branch"] || 3,
-    attemptsPerIssue: profileSection["max-attempts-per-issue"] || 2,
-    featuresLimit: profileSection["features-limit"] || 4,
-    libraryLimit: profileSection["library-limit"] || 32,
-  };
-}
-
-/**
- * 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)
- * @param {string} depsRelPath - Relative path to package.json (from config)
- * @returns {string} Raw package.json content or empty string
- */
-function readPackageJson(tomlPath, depsRelPath) {
-  try {
-    const projectRoot = dirname(tomlPath);
-    const pkgPath = join(projectRoot, depsRelPath);
-    return existsSync(pkgPath) ? readFileSync(pkgPath, "utf8") : "";
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Resolve tuning configuration: start from profile defaults, apply explicit overrides.
- * @param {Object} tuningSection - The [tuning] section from TOML
- * @param {Object} [profilesSection] - The [profiles] section from TOML (source of truth)
- */
-function resolveTuning(tuningSection, profilesSection) {
-  const profileName = tuningSection.profile || "recommended";
-  const tomlProfile = profilesSection?.[profileName];
-  const profile = parseTuningProfile(tomlProfile) || FALLBACK_TUNING;
-  const tuning = { ...profile, profileName };
-
-  // "none" explicitly disables reasoning-effort regardless of profile
-  if (tuningSection["reasoning-effort"]) {
-    tuning.reasoningEffort = tuningSection["reasoning-effort"] === "none" ? "" : tuningSection["reasoning-effort"];
-  }
-  if (tuningSection["infinite-sessions"] === true || tuningSection["infinite-sessions"] === false) {
-    tuning.infiniteSessions = tuningSection["infinite-sessions"];
-  }
-  const numericOverrides = {
-    "transformation-budget": "transformationBudget",
-    "max-feature-files": "featuresScan",
-    "max-source-files": "sourceScan",
-    "max-source-chars": "sourceContent",
-    "max-test-chars": "testContent",
-    "max-issues": "issuesScan",
-    "issue-body-limit": "issueBodyLimit",
-    "stale-days": "staleDays",
-    "max-summary-chars": "documentSummary",
-    "max-discussion-comments": "discussionComments",
-  };
-  for (const [tomlKey, jsKey] of Object.entries(numericOverrides)) {
-    if (tuningSection[tomlKey] > 0) tuning[jsKey] = tuningSection[tomlKey];
-  }
-
-  return tuning;
-}
-
-/**
- * Resolve limits configuration: start from profile defaults, apply explicit overrides.
- * @param {Object} limitsSection - The [limits] section from TOML
- * @param {string} profileName - Active profile name
- * @param {Object} [profilesSection] - The [profiles] section from TOML (source of truth)
- */
-function resolveLimits(limitsSection, profileName, profilesSection) {
-  const tomlProfile = profilesSection?.[profileName];
-  const profile = parseLimitsProfile(tomlProfile) || FALLBACK_LIMITS;
-  return {
-    featureIssues: limitsSection["max-feature-issues"] || profile.featureIssues,
-    maintenanceIssues: limitsSection["max-maintenance-issues"] || profile.maintenanceIssues,
-    attemptsPerBranch: limitsSection["max-attempts-per-branch"] || profile.attemptsPerBranch,
-    attemptsPerIssue: limitsSection["max-attempts-per-issue"] || profile.attemptsPerIssue,
-    featuresLimit: limitsSection["features-limit"] || profile.featuresLimit,
-    libraryLimit: limitsSection["library-limit"] || profile.libraryLimit,
-  };
-}
-
-/**
- * Load configuration from agentic-lib.toml.
- *
- * If configPath ends in .toml, it is used directly.
- * Otherwise, the project root is derived (3 levels up from configPath)
- * and agentic-lib.toml is loaded from there.
- *
- * @param {string} configPath - Path to config file or YAML path (for project root derivation)
- * @returns {AgenticConfig} Parsed configuration object
- * @throws {Error} If no TOML config file is found
- */
-export function loadConfig(configPath) {
-  let tomlPath;
-  if (configPath.endsWith(".toml")) {
-    tomlPath = configPath;
-  } else {
-    const configDir = dirname(configPath);
-    const projectRoot = join(configDir, "..", "..", "..");
-    tomlPath = join(projectRoot, "agentic-lib.toml");
-  }
-
-  if (!existsSync(tomlPath)) {
-    throw new Error(`Config file not found: ${tomlPath}. Create agentic-lib.toml in the project root.`);
-  }
-
-  const rawToml = readFileSync(tomlPath, "utf8");
-  const toml = parseToml(rawToml);
-
-  // Merge TOML paths with defaults, normalising library-sources → librarySources
-  const rawPaths = { ...toml.paths };
-  if (rawPaths["library-sources"]) {
-    rawPaths.librarySources = rawPaths["library-sources"];
-    delete rawPaths["library-sources"];
-  }
-  const mergedPaths = { ...PATH_DEFAULTS, ...rawPaths };
-
-  // Build path objects with permissions
-  const paths = {};
-  const writablePaths = [];
-  const readOnlyPaths = [];
-
-  for (const [key, value] of Object.entries(mergedPaths)) {
-    const isWritable = WRITABLE_KEYS.includes(key);
-    paths[key] = { path: value, permissions: isWritable ? ["write"] : [] };
-    if (isWritable) {
-      writablePaths.push(value);
-    } else {
-      readOnlyPaths.push(value);
-    }
-  }
-
-  const profilesSection = toml.profiles || {};
-  const tuning = resolveTuning(toml.tuning || {}, profilesSection);
-  const limitsSection = toml.limits || {};
-  const resolvedLimits = resolveLimits(limitsSection, tuning.profileName, profilesSection);
-
-  // Apply resolved limits to path objects
-  paths.features.limit = resolvedLimits.featuresLimit;
-  paths.library.limit = resolvedLimits.libraryLimit;
-
-  const execution = toml.execution || {};
-  const bot = toml.bot || {};
-
-  // Mission-complete thresholds (with safe defaults)
-  const mc = toml["mission-complete"] || {};
-  const missionCompleteThresholds = {
-    minResolvedIssues: mc["min-resolved-issues"] ?? 3,
-    minDedicatedTests: mc["min-dedicated-tests"] ?? (mc["require-dedicated-tests"] === false ? 0 : 1),
-    maxSourceTodos: mc["max-source-todos"] ?? 0,
-  };
-
-  return {
-    supervisor: toml.schedule?.supervisor || "daily",
-    model: toml.tuning?.model || toml.schedule?.model || "gpt-5-mini",
-    tuning,
-    paths,
-    testScript: execution.test || "npm ci && npm test",
-    featureDevelopmentIssuesWipLimit: resolvedLimits.featureIssues,
-    maintenanceIssuesWipLimit: resolvedLimits.maintenanceIssues,
-    attemptsPerBranch: resolvedLimits.attemptsPerBranch,
-    attemptsPerIssue: resolvedLimits.attemptsPerIssue,
-    transformationBudget: tuning.transformationBudget,
-    seeding: toml.seeding || {},
-    intentionBot: {
-      intentionFilepath: bot["log-file"] || "intentïon.md",
-    },
-    init: toml.init || null,
-    tdd: toml.tdd === true,
-    missionCompleteThresholds,
-    writablePaths,
-    readOnlyPaths,
-    configToml: rawToml,
-    packageJson: readPackageJson(tomlPath, mergedPaths.dependencies),
-  };
-}
-
-/**
- * Get the writable paths from config, optionally overridden by an input string.
- *
- * @param {AgenticConfig} config - Parsed config
- * @param {string} [override] - Semicolon-separated override paths
- * @returns {string[]} Array of writable paths
- */
-export function getWritablePaths(config, override) {
-  if (override) {
-    return override
-      .split(";")
-      .map((p) => p.trim())
-      .filter(Boolean);
-  }
-  return config.writablePaths;
-}
+export { loadConfig, getWritablePaths } from "../../copilot/config.js";