@runfusion/fusion 0.18.1 → 0.19.0

package/dist/extension.js

@@ -91,6 +91,7 @@ var init_settings_schema = __esm({
       modelOnboardingComplete: void 0,
       useClaudeCli: void 0,
       useDroidCli: void 0,
+      useLlamaCpp: void 0,
       // Global baseline lanes for per-role model selection
       executionGlobalProvider: void 0,
       executionGlobalModelId: void 0,
@@ -2771,7 +2772,7 @@ var init_db = __esm({
     "use strict";
     init_sqlite_adapter();
     init_types();
-    SCHEMA_VERSION = 60;
+    SCHEMA_VERSION = 61;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
 CREATE TABLE IF NOT EXISTS tasks (
@@ -4643,6 +4644,21 @@ This means a caller passed a .fusion directory where a project root was expected
             this.db.exec(`CREATE INDEX IF NOT EXISTS idxTasksPausedByAgentId ON tasks(pausedByAgentId)`);
           });
         }
+        if (version < 61) {
+          this.applyMigration(61, () => {
+            this.db.exec(`
+          CREATE TABLE IF NOT EXISTS verification_cache (
+            treeSha TEXT NOT NULL,
+            testCommand TEXT NOT NULL DEFAULT '',
+            buildCommand TEXT NOT NULL DEFAULT '',
+            recordedAt TEXT NOT NULL,
+            taskId TEXT,
+            PRIMARY KEY (treeSha, testCommand, buildCommand)
+          )
+        `);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idxVerificationCacheRecordedAt ON verification_cache(recordedAt)`);
+          });
+        }
       }
       /**
        * Run a single migration step inside a transaction and bump the version.
@@ -5078,6 +5094,33 @@ var init_agent_store = __esm({
     `).run(migrationKey, migrationVersion);
         this.db.bumpLastModified();
       }
+      /**
+       * Find the first non-ephemeral agent by exact name.
+       *
+       * Ephemeral task-worker/spawned agents are excluded so callers can use this
+       * for durable identity checks without transient runtime workers conflicting.
+       *
+       * @param name - Agent name to match exactly
+       * @returns Matching non-ephemeral agent, or null when none exists
+       */
+      async findAgentByName(name) {
+        const rows = this.db.prepare("SELECT * FROM agents WHERE name = ? ORDER BY createdAt DESC").all(name);
+        for (const row of rows) {
+          const agent = this.mapAgentRow(row);
+          if (!isEphemeralAgent(agent)) {
+            return agent;
+          }
+        }
+        return null;
+      }
+      async hasNonEphemeralAgentWithName(name) {
+        const normalizedName = name.trim();
+        if (!normalizedName) {
+          return false;
+        }
+        const existing = await this.findAgentByName(normalizedName);
+        return existing !== null;
+      }
       /**
        * Create a new agent with "idle" state.
        *
@@ -5090,9 +5133,12 @@ var init_agent_store = __esm({
        * same default (1h) to both at runtime. Writing the default explicitly
        * removes that divergence and keeps the persisted config truthful.
        *
+       * Also enforces non-ephemeral name uniqueness: durable agents cannot share a
+       * name, while ephemeral task-worker agents are allowed to duplicate names.
+       *
        * @param input - Creation parameters
        * @returns The created agent
-       * @throws Error if input is invalid
+       * @throws Error if input is invalid or a duplicate non-ephemeral name exists
        */
       async createAgent(input) {
         if (!input.name?.trim()) {
@@ -5101,15 +5147,22 @@ var init_agent_store = __esm({
         if (!input.role) {
           throw new Error("Agent role is required");
         }
+        const normalizedName = input.name.trim();
+        const metadata = input.metadata ?? {};
+        const ephemeral = isEphemeralAgent({ metadata, name: input.name, role: input.role, reportsTo: input.reportsTo });
+        if (!ephemeral) {
+          const existing = await this.findAgentByName(normalizedName);
+          if (existing) {
+            throw new Error(`Agent with name "${normalizedName}" already exists (agentId: ${existing.id})`);
+          }
+        }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const agentId = `agent-${randomUUID().slice(0, 8)}`;
-        const metadata = input.metadata ?? {};
         const runtimeConfig = resolveCreationRuntimeConfig(input.runtimeConfig, metadata);
-        const ephemeral = isEphemeralAgent({ metadata, name: input.name, role: input.role, reportsTo: input.reportsTo });
         const resolvedHeartbeatProcedurePath = input.heartbeatProcedurePath ?? (ephemeral ? void 0 : getDefaultHeartbeatProcedurePath(agentId, input.name));
         const agent = {
           id: agentId,
-          name: input.name.trim(),
+          name: normalizedName,
           role: input.role,
           state: "idle",
           createdAt: now,
@@ -19457,10 +19510,10 @@ var init_central_core = __esm({
        */
       async generateProjectName(projectPath) {
         try {
-          const { execFile: execFile7 } = await import("node:child_process");
+          const { execFile: execFile8 } = await import("node:child_process");
           const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync5 = promisify14(execFile7);
-          const { stdout } = await execFileAsync5(
+          const execFileAsync6 = promisify14(execFile8);
+          const { stdout } = await execFileAsync6(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 5e3 }
@@ -20128,10 +20181,10 @@ var init_migration = __esm({
           return basename3(projectPath);
         }
         try {
-          const { execFile: execFile7 } = await import("node:child_process");
+          const { execFile: execFile8 } = await import("node:child_process");
           const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync5 = promisify14(execFile7);
-          const { stdout } = await execFileAsync5(
+          const execFileAsync6 = promisify14(execFile8);
+          const { stdout } = await execFileAsync6(
             "git",
             ["remote", "get-url", "origin"],
             { cwd: projectPath, timeout: 1e3 }
@@ -30835,13 +30888,13 @@ async function searchWithQmd(rootDir, options) {
   const command = "qmd";
   const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
   try {
-    const { execFile: execFile7 } = await import("node:child_process");
+    const { execFile: execFile8 } = await import("node:child_process");
     const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync5 = promisify14(execFile7);
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync5);
+    const execFileAsync6 = promisify14(execFile8);
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
     scheduleQmdProjectMemoryRefresh(rootDir);
     const args = buildQmdSearchArgs(rootDir, options);
-    const { stdout } = await execFileAsync5(command, args, {
+    const { stdout } = await execFileAsync6(command, args, {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -30866,12 +30919,12 @@ async function searchWithQmd(rootDir, options) {
     return [];
   }
 }
-async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync5) {
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync6) {
   const collectionName = qmdMemoryCollectionName(rootDir);
   const memoryDir = memoryWorkspacePath(rootDir);
   await mkdir6(memoryDir, { recursive: true });
   try {
-    await execFileAsync5("qmd", buildQmdCollectionAddArgs(rootDir), {
+    await execFileAsync6("qmd", buildQmdCollectionAddArgs(rootDir), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 512 * 1024
@@ -30887,9 +30940,9 @@ ${stderr}`)) {
   return collectionName;
 }
 async function getDefaultExecFileAsync() {
-  const { execFile: execFile7 } = await import("node:child_process");
+  const { execFile: execFile8 } = await import("node:child_process");
   const { promisify: promisify14 } = await import("node:util");
-  return promisify14(execFile7);
+  return promisify14(execFile8);
 }
 async function refreshQmdProjectMemoryIndex(rootDir, options) {
   const key = resolve6(rootDir);
@@ -30904,14 +30957,14 @@ async function refreshQmdProjectMemoryIndex(rootDir, options) {
     }
   }
   const promise = (async () => {
-    const execFileAsync5 = options?.execFileAsync ?? await getDefaultExecFileAsync();
-    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync5);
-    await execFileAsync5("qmd", ["update"], {
+    const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync6);
+    await execFileAsync6("qmd", ["update"], {
       cwd: rootDir,
       timeout: 3e4,
       maxBuffer: 1024 * 1024
     });
-    await execFileAsync5("qmd", ["embed"], {
+    await execFileAsync6("qmd", ["embed"], {
       cwd: rootDir,
       timeout: 12e4,
       maxBuffer: 1024 * 1024
@@ -30936,8 +30989,8 @@ function scheduleQmdProjectMemoryRefresh(rootDir) {
 }
 async function isQmdAvailable() {
   try {
-    const execFileAsync5 = await getDefaultExecFileAsync();
-    await execFileAsync5("qmd", ["--help"], {
+    const execFileAsync6 = await getDefaultExecFileAsync();
+    await execFileAsync6("qmd", ["--help"], {
       timeout: 3e3,
       maxBuffer: 128 * 1024
     });
@@ -30947,12 +31000,12 @@ async function isQmdAvailable() {
   }
 }
 async function installQmd(options) {
-  const execFileAsync5 = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const execFileAsync6 = options?.execFileAsync ?? await getDefaultExecFileAsync();
   const [command, ...args] = QMD_INSTALL_COMMAND.split(" ");
   if (!command || args.length === 0) {
     throw new MemoryBackendError("BACKEND_UNAVAILABLE", "qmd install command is not configured", "qmd");
   }
-  await execFileAsync5(command, args, {
+  await execFileAsync6(command, args, {
     timeout: 12e4,
     maxBuffer: 1024 * 1024
   });
@@ -37212,6 +37265,42 @@ ${notificationsSection}`;
         }
         return this.todoStore;
       }
+      // ── Verification Cache ────────────────────────────────────────────────────
+      /**
+       * Look up a previously recorded verification cache pass for a given tree sha
+       * and command pair. Returns null when no cached pass exists.
+       *
+       * @param treeSha - The git tree SHA of the merged commit.
+       * @param testCommand - The test command string (normalized to empty string when absent).
+       * @param buildCommand - The build command string (normalized to empty string when absent).
+       */
+      getVerificationCacheHit(treeSha, testCommand, buildCommand2) {
+        const normalizedTest = testCommand ?? "";
+        const normalizedBuild = buildCommand2 ?? "";
+        const row = this.db.prepare(
+          `SELECT recordedAt, taskId FROM verification_cache
+         WHERE treeSha = ? AND testCommand = ? AND buildCommand = ?`
+        ).get(treeSha, normalizedTest, normalizedBuild);
+        return row ?? null;
+      }
+      /**
+       * Record a successful verification pass for the given tree sha and commands.
+       * Uses INSERT OR REPLACE so a re-run of the same tree updates the timestamp.
+       *
+       * @param treeSha - The git tree SHA of the merged commit.
+       * @param testCommand - The test command string (normalized to empty string when absent).
+       * @param buildCommand - The build command string (normalized to empty string when absent).
+       * @param taskId - The task ID that triggered the pass (for telemetry).
+       */
+      recordVerificationCachePass(treeSha, testCommand, buildCommand2, taskId) {
+        const normalizedTest = testCommand ?? "";
+        const normalizedBuild = buildCommand2 ?? "";
+        const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare(
+          `INSERT OR REPLACE INTO verification_cache (treeSha, testCommand, buildCommand, recordedAt, taskId)
+         VALUES (?, ?, ?, ?, ?)`
+        ).run(treeSha, normalizedTest, normalizedBuild, recordedAt, taskId);
+      }
       // ── Backward Compatibility (Multi-Project Support) ────────────────────────
     };
   }
@@ -40579,7 +40668,7 @@ var init_docker_provisioning = __esm({
 });
 
 // ../core/src/memory-insights.ts
-import { readFile as readFile11, writeFile as writeFile8, mkdir as mkdir9 } from "node:fs/promises";
+import { readFile as readFile11, writeFile as writeFile8, mkdir as mkdir9, unlink as unlink5 } from "node:fs/promises";
 import { existsSync as existsSync17 } from "node:fs";
 import { dirname as dirname7, join as join19 } from "node:path";
 async function readWorkingMemory(rootDir) {
@@ -40589,7 +40678,35 @@ async function readWorkingMemory(rootDir) {
   }
   return readFile11(filePath, "utf-8");
 }
+async function migrateLegacyArtifactIfNeeded(rootDir, canonicalPath, legacyPath) {
+  const canonicalFilePath = join19(rootDir, canonicalPath);
+  const legacyFilePath = join19(rootDir, legacyPath);
+  if (existsSync17(canonicalFilePath) || !existsSync17(legacyFilePath)) {
+    return;
+  }
+  const content = await readFile11(legacyFilePath, "utf-8");
+  const canonicalDir = dirname7(canonicalFilePath);
+  if (!existsSync17(canonicalDir)) {
+    await mkdir9(canonicalDir, { recursive: true });
+  }
+  await writeFile8(canonicalFilePath, content, "utf-8");
+  try {
+    await unlink5(legacyFilePath);
+  } catch {
+  }
+}
+async function removeLegacyArtifactIfPresent(rootDir, legacyPath) {
+  const legacyFilePath = join19(rootDir, legacyPath);
+  if (!existsSync17(legacyFilePath)) {
+    return;
+  }
+  try {
+    await unlink5(legacyFilePath);
+  } catch {
+  }
+}
 async function readInsightsMemory(rootDir) {
+  await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_INSIGHTS_PATH, LEGACY_MEMORY_INSIGHTS_PATH);
   const filePath = join19(rootDir, MEMORY_INSIGHTS_PATH);
   if (!existsSync17(filePath)) {
     return null;
@@ -40598,11 +40715,12 @@ async function readInsightsMemory(rootDir) {
 }
 async function writeInsightsMemory(rootDir, content) {
   const filePath = join19(rootDir, MEMORY_INSIGHTS_PATH);
-  const dir = join19(rootDir, ".fusion");
+  const dir = dirname7(filePath);
   if (!existsSync17(dir)) {
     await mkdir9(dir, { recursive: true });
   }
   await writeFile8(filePath, content, "utf-8");
+  await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_INSIGHTS_PATH);
 }
 async function writeWorkingMemory(rootDir, content) {
   const filePath = join19(rootDir, MEMORY_WORKING_PATH);
@@ -40613,6 +40731,7 @@ async function writeWorkingMemory(rootDir, content) {
   await writeFile8(filePath, content, "utf-8");
 }
 async function readMemoryAudit(rootDir) {
+  await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_AUDIT_PATH, LEGACY_MEMORY_AUDIT_PATH);
   const filePath = join19(rootDir, MEMORY_AUDIT_PATH);
   if (!existsSync17(filePath)) {
     return null;
@@ -40621,13 +40740,15 @@ async function readMemoryAudit(rootDir) {
 }
 async function writeMemoryAudit(rootDir, content) {
   const filePath = join19(rootDir, MEMORY_AUDIT_PATH);
-  const dir = join19(rootDir, ".fusion");
+  const dir = dirname7(filePath);
   if (!existsSync17(dir)) {
     await mkdir9(dir, { recursive: true });
   }
   await writeFile8(filePath, content, "utf-8");
+  await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_AUDIT_PATH);
 }
 async function readMemoryAuditState(rootDir) {
+  await migrateLegacyArtifactIfNeeded(rootDir, MEMORY_AUDIT_STATE_PATH, LEGACY_MEMORY_AUDIT_STATE_PATH);
   const filePath = join19(rootDir, MEMORY_AUDIT_STATE_PATH);
   if (!existsSync17(filePath)) {
     return null;
@@ -40648,11 +40769,12 @@ async function readMemoryAuditState(rootDir) {
 }
 async function writeMemoryAuditState(rootDir, state) {
   const filePath = join19(rootDir, MEMORY_AUDIT_STATE_PATH);
-  const dir = join19(rootDir, ".fusion");
+  const dir = dirname7(filePath);
   if (!existsSync17(dir)) {
     await mkdir9(dir, { recursive: true });
   }
   await writeFile8(filePath, JSON.stringify(state, null, 2), "utf-8");
+  await removeLegacyArtifactIfPresent(rootDir, LEGACY_MEMORY_AUDIT_STATE_PATH);
 }
 function isValidExtractionMetadata(value) {
   if (!value || typeof value !== "object") {
@@ -40927,7 +41049,7 @@ function createInsightExtractionAutomation(settings, modelProvider, modelId) {
 ## Instructions
 
 1. Read the working memory file at \`.fusion/memory/MEMORY.md\` using your file reading tools
-2. Read the existing insights file at \`.fusion/memory-insights.md\` (it may not exist yet)
+2. Read the existing insights file at \`.fusion/memory/memory-insights.md\` (it may not exist yet)
 3. Analyze the working memory content and identify:
    a) **New insights** that should be preserved in long-term memory
    b) **Durable content** that should remain in working memory
@@ -41231,7 +41353,7 @@ async function generateMemoryAudit(rootDir, lastExtraction, pruningOutcome) {
       id: "insights-memory-exists",
       name: "Insights memory file exists",
       passed: false,
-      details: "File .fusion/memory-insights.md does not exist yet"
+      details: "File .fusion/memory/memory-insights.md does not exist yet"
     });
   }
   if (insightsMemoryExists) {
@@ -41477,14 +41599,17 @@ async function processAndAuditInsightExtraction(rootDir, input) {
   }
   return auditReport;
 }
-var MEMORY_WORKING_PATH, MEMORY_INSIGHTS_PATH, MEMORY_AUDIT_PATH, MEMORY_AUDIT_STATE_PATH, DEFAULT_INSIGHT_SCHEDULE, DEFAULT_MIN_INTERVAL_MS, MIN_INSIGHT_GROWTH_CHARS, INSIGHT_EXTRACTION_SCHEDULE_NAME, REQUIRED_MEMORY_SECTIONS;
+var MEMORY_WORKING_PATH, MEMORY_INSIGHTS_PATH, MEMORY_AUDIT_PATH, MEMORY_AUDIT_STATE_PATH, LEGACY_MEMORY_INSIGHTS_PATH, LEGACY_MEMORY_AUDIT_PATH, LEGACY_MEMORY_AUDIT_STATE_PATH, DEFAULT_INSIGHT_SCHEDULE, DEFAULT_MIN_INTERVAL_MS, MIN_INSIGHT_GROWTH_CHARS, INSIGHT_EXTRACTION_SCHEDULE_NAME, REQUIRED_MEMORY_SECTIONS;
 var init_memory_insights = __esm({
   "../core/src/memory-insights.ts"() {
     "use strict";
     MEMORY_WORKING_PATH = ".fusion/memory/MEMORY.md";
-    MEMORY_INSIGHTS_PATH = ".fusion/memory-insights.md";
-    MEMORY_AUDIT_PATH = ".fusion/memory-audit.md";
-    MEMORY_AUDIT_STATE_PATH = ".fusion/memory-audit-state.json";
+    MEMORY_INSIGHTS_PATH = ".fusion/memory/memory-insights.md";
+    MEMORY_AUDIT_PATH = ".fusion/memory/memory-audit.md";
+    MEMORY_AUDIT_STATE_PATH = ".fusion/memory/memory-audit-state.json";
+    LEGACY_MEMORY_INSIGHTS_PATH = ".fusion/memory-insights.md";
+    LEGACY_MEMORY_AUDIT_PATH = ".fusion/memory-audit.md";
+    LEGACY_MEMORY_AUDIT_STATE_PATH = ".fusion/memory-audit-state.json";
     DEFAULT_INSIGHT_SCHEDULE = "0 2 * * *";
     DEFAULT_MIN_INTERVAL_MS = 24 * 60 * 60 * 1e3;
     MIN_INSIGHT_GROWTH_CHARS = 1e3;
@@ -51895,12 +52020,12 @@ function resolveExtractionRoot(tempDir) {
   return tempDir;
 }
 async function extractTarArchive(archivePath, outputDir) {
-  const [{ execFile: execFile7 }, { promisify: promisify14 }] = await Promise.all([
+  const [{ execFile: execFile8 }, { promisify: promisify14 }] = await Promise.all([
     import("node:child_process"),
     import("node:util")
   ]);
-  const execFileAsync5 = promisify14(execFile7);
-  await execFileAsync5("tar", ["xzf", archivePath, "-C", outputDir]);
+  const execFileAsync6 = promisify14(execFile8);
+  await execFileAsync6("tar", ["xzf", archivePath, "-C", outputDir]);
 }
 async function parseCompanyArchive(archivePath) {
   const resolvedArchivePath = resolve9(archivePath);
@@ -54016,7 +54141,13 @@ var init_research_orchestrator = __esm({
             continue;
           }
           for (const source of result.data.slice(0, Math.max(0, config.maxSources - allSources.length))) {
-            const saved = this.store.addSource(runId, source);
+            const saved = this.store.addSource(runId, {
+              ...source,
+              metadata: {
+                ...source.metadata ?? {},
+                providerType: provider.type
+              }
+            });
             allSources.push(saved);
             this.store.addEvent(runId, {
               type: "source_added",
@@ -54043,7 +54174,9 @@ var init_research_orchestrator = __esm({
             sourceId: source.id
           });
           this.stepStarted(runId, step);
-          const result = await this.stepRunner.runContentFetch(source.reference, provider?.config, signal);
+          const sourceProvider = this.getSourceProviderType(source);
+          const providerConfig = sourceProvider ? config.providers.find((p) => p.type === sourceProvider)?.config : provider?.config;
+          const result = await this.stepRunner.runContentFetch(source.reference, sourceProvider, providerConfig, signal);
           if (!result.ok || !result.data) {
             this.stepFailed(runId, step.id, result.error?.message ?? "Failed to fetch source content", result.error);
             continue;
@@ -54242,6 +54375,10 @@ var init_research_orchestrator = __esm({
           throw signal.reason ?? new Error("Research run aborted");
         }
       }
+      getSourceProviderType(source) {
+        const providerType = source.metadata?.providerType;
+        return typeof providerType === "string" && providerType.length > 0 ? providerType : void 0;
+      }
       canWriteRunData(runId) {
         const run = this.store.getRun(runId);
         if (!run) return false;
@@ -56805,8 +56942,8 @@ var init_research_step_runner = __esm({
           return this.classifyError("source-query", error);
         }
       }
-      async runContentFetch(url, config = {}, signal) {
-        const provider = this.findFirstConfiguredProvider();
+      async runContentFetch(url, providerType, config = {}, signal) {
+        const provider = this.resolveContentProvider(providerType);
         if (!provider) {
           return this.unconfigured("no configured provider available for content fetch");
         }
@@ -56845,6 +56982,13 @@ var init_research_step_runner = __esm({
         }
         return void 0;
       }
+      resolveContentProvider(providerType) {
+        if (providerType) {
+          const selected = this.providers.get(providerType);
+          if (selected?.isConfigured()) return selected;
+        }
+        return this.findFirstConfiguredProvider();
+      }
       classifyError(step, error) {
         if (error instanceof ResearchStepTimeoutError) {
           return { ok: false, error: { code: "timeout", message: error.message, retryable: true } };
@@ -57057,11 +57201,11 @@ async function refreshAgentMemoryQmdIndex(rootDir, agentMemory) {
     return;
   }
   const promise = (async () => {
-    const { execFile: execFile7 } = await import("node:child_process");
+    const { execFile: execFile8 } = await import("node:child_process");
     const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync5 = promisify14(execFile7);
+    const execFileAsync6 = promisify14(execFile8);
     try {
-      await execFileAsync5("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
+      await execFileAsync6("qmd", buildQmdAgentMemoryCollectionAddArgs(rootDir, agentMemory.agentId), {
         cwd: rootDir,
         timeout: 4e3,
         maxBuffer: 512 * 1024
@@ -57074,8 +57218,8 @@ ${stderr}`)) {
         throw error;
       }
     }
-    await execFileAsync5("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
-    await execFileAsync5("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync6("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync6("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
   })();
   agentQmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
   try {
@@ -57123,10 +57267,10 @@ async function searchAgentMemoryWithQmd(rootDir, agentMemory, query, limit) {
   }
   try {
     await refreshAgentMemoryQmdIndex(rootDir, agentMemory);
-    const { execFile: execFile7 } = await import("node:child_process");
+    const { execFile: execFile8 } = await import("node:child_process");
     const { promisify: promisify14 } = await import("node:util");
-    const execFileAsync5 = promisify14(execFile7);
-    const { stdout } = await execFileAsync5("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
+    const execFileAsync6 = promisify14(execFile8);
+    const { stdout } = await execFileAsync6("qmd", buildQmdAgentMemorySearchArgs(rootDir, agentMemory.agentId, query, limit), {
       cwd: rootDir,
       timeout: 4e3,
       maxBuffer: 1024 * 1024
@@ -57567,6 +57711,151 @@ ${lines.join("\n\n")}` }],
     }
   };
 }
+function createGetAgentConfigTool(agentStore, callingAgentId) {
+  return {
+    name: "fn_get_agent_config",
+    label: "Get Agent Config",
+    description: "Read full configuration for one of your direct-report agents.",
+    parameters: getAgentConfigParams,
+    execute: async (_id, params) => {
+      const target = await agentStore.getAgent(params.agent_id);
+      if (!target) {
+        return {
+          content: [{ type: "text", text: `ERROR: Agent ${params.agent_id} not found` }],
+          details: {}
+        };
+      }
+      if (target.reportsTo !== callingAgentId) {
+        return {
+          content: [{ type: "text", text: "ERROR: You can only read configuration of agents that report to you" }],
+          details: {}
+        };
+      }
+      const runtimeConfig = target.runtimeConfig ?? {};
+      const lines = [
+        `Agent Config: ${target.name} (${target.id})`,
+        `Role: ${target.role}`,
+        `State: ${target.state}`,
+        `Title: ${target.title ?? "(none)"}`,
+        `Icon: ${target.icon ?? "(none)"}`,
+        "",
+        "Soul:",
+        target.soul ?? "(none)",
+        "",
+        "Instructions Text:",
+        target.instructionsText ?? "(none)",
+        `Instructions Path: ${target.instructionsPath ?? "(none)"}`,
+        `Heartbeat Procedure Path: ${target.heartbeatProcedurePath ?? "(none)"}`,
+        "",
+        "Runtime Config:",
+        `heartbeatIntervalMs: ${String(runtimeConfig.heartbeatIntervalMs ?? "(default)")}`,
+        `heartbeatTimeoutMs: ${String(runtimeConfig.heartbeatTimeoutMs ?? "(default)")}`,
+        `maxConcurrentRuns: ${String(runtimeConfig.maxConcurrentRuns ?? "(default)")}`,
+        `messageResponseMode: ${String(runtimeConfig.messageResponseMode ?? "(default)")}`,
+        `budget: ${JSON.stringify(runtimeConfig.budget ?? null)}`,
+        "",
+        "Memory:",
+        target.memory ?? "(none)"
+      ];
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: { agent: target }
+      };
+    }
+  };
+}
+function createUpdateAgentConfigTool(agentStore, callingAgentId) {
+  return {
+    name: "fn_update_agent_config",
+    label: "Update Agent Config",
+    description: "Update configuration for one of your direct-report agents.",
+    parameters: updateAgentConfigParams,
+    execute: async (_id, params) => {
+      const target = await agentStore.getAgent(params.agent_id);
+      if (!target) {
+        return {
+          content: [{ type: "text", text: `ERROR: Agent ${params.agent_id} not found` }],
+          details: {}
+        };
+      }
+      if (target.reportsTo !== callingAgentId) {
+        return {
+          content: [{ type: "text", text: "ERROR: You can only update configuration of agents that report to you" }],
+          details: {}
+        };
+      }
+      if (isEphemeralAgent(target)) {
+        return {
+          content: [{ type: "text", text: `ERROR: Cannot update ephemeral/runtime agent ${params.agent_id}` }],
+          details: {}
+        };
+      }
+      if (params.soul && params.soul.length > 1e4) {
+        return {
+          content: [{ type: "text", text: "ERROR: soul exceeds 10000 character limit" }],
+          details: {}
+        };
+      }
+      if (params.instructions_text && params.instructions_text.length > 5e4) {
+        return {
+          content: [{ type: "text", text: "ERROR: instructions_text exceeds 50000 character limit" }],
+          details: {}
+        };
+      }
+      if (params.instructions_path && params.instructions_path.length > 500) {
+        return {
+          content: [{ type: "text", text: "ERROR: instructions_path exceeds 500 character limit" }],
+          details: {}
+        };
+      }
+      if (params.heartbeat_procedure_path && params.heartbeat_procedure_path.length > 500) {
+        return {
+          content: [{ type: "text", text: "ERROR: heartbeat_procedure_path exceeds 500 character limit" }],
+          details: {}
+        };
+      }
+      const hasRuntimeConfigUpdates = [
+        params.heartbeat_interval_ms,
+        params.heartbeat_timeout_ms,
+        params.max_concurrent_runs,
+        params.message_response_mode
+      ].some((value) => value !== void 0);
+      const updateInput = {};
+      if (params.soul !== void 0) updateInput.soul = params.soul;
+      if (params.instructions_text !== void 0) updateInput.instructionsText = params.instructions_text;
+      if (params.instructions_path !== void 0) updateInput.instructionsPath = params.instructions_path;
+      if (params.heartbeat_procedure_path !== void 0) updateInput.heartbeatProcedurePath = params.heartbeat_procedure_path;
+      if (hasRuntimeConfigUpdates) {
+        updateInput.runtimeConfig = {
+          ...target.runtimeConfig ?? {},
+          ...params.heartbeat_interval_ms !== void 0 ? { heartbeatIntervalMs: params.heartbeat_interval_ms } : {},
+          ...params.heartbeat_timeout_ms !== void 0 ? { heartbeatTimeoutMs: params.heartbeat_timeout_ms } : {},
+          ...params.max_concurrent_runs !== void 0 ? { maxConcurrentRuns: params.max_concurrent_runs } : {},
+          ...params.message_response_mode !== void 0 ? { messageResponseMode: params.message_response_mode } : {}
+        };
+      }
+      if (Object.keys(updateInput).length === 0) {
+        return {
+          content: [{ type: "text", text: "ERROR: Provide at least one field to update" }],
+          details: {}
+        };
+      }
+      const updated = await agentStore.updateAgent(params.agent_id, updateInput);
+      const updatedRuntimeConfig = updated.runtimeConfig ?? {};
+      return {
+        content: [{
+          type: "text",
+          text: `Updated ${updated.name} (${updated.id})
+heartbeatIntervalMs: ${String(updatedRuntimeConfig.heartbeatIntervalMs ?? "(default)")}
+heartbeatTimeoutMs: ${String(updatedRuntimeConfig.heartbeatTimeoutMs ?? "(default)")}
+maxConcurrentRuns: ${String(updatedRuntimeConfig.maxConcurrentRuns ?? "(default)")}
+messageResponseMode: ${String(updatedRuntimeConfig.messageResponseMode ?? "(default)")}`
+        }],
+        details: { agent: updated }
+      };
+    }
+  };
+}
 function createDelegateTaskTool(agentStore, taskStore, options) {
   return {
     name: "fn_delegate_task",
@@ -57896,7 +58185,7 @@ ${lines.join("\n")}`
     }
   };
 }
-var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, listAgentsParams, delegateTaskParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log11, AGENT_MEMORY_ROOT2, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
+var taskCreateParams, taskLogParams, taskDocumentWriteParams, taskDocumentReadParams, reflectOnPerformanceParams, listAgentsParams, delegateTaskParams, getAgentConfigParams, updateAgentConfigParams, sendMessageParams, readMessagesParams, memorySearchParams, memoryGetParams, researchRunParams, researchListParams, researchGetParams, researchCancelParams, memoryAppendParams, log11, AGENT_MEMORY_ROOT2, AGENT_MEMORY_FILENAME2, AGENT_DREAMS_FILENAME2, agentQmdRefreshState, AGENT_QMD_REFRESH_INTERVAL_MS, DAILY_AGENT_MEMORY_RE2;
 var init_agent_tools = __esm({
   "../engine/src/agent-tools.ts"() {
     "use strict";
@@ -57950,6 +58239,23 @@ var init_agent_tools = __esm({
         Type.Array(Type.String(), { description: 'Task IDs this new task depends on (e.g. ["KB-001"])' })
       )
     });
+    getAgentConfigParams = Type.Object({
+      agent_id: Type.String({ description: "The agent ID to read configuration for" })
+    });
+    updateAgentConfigParams = Type.Object({
+      agent_id: Type.String({ description: "The agent ID to update" }),
+      soul: Type.Optional(Type.String({ description: "Agent personality/identity text", maxLength: 1e4 })),
+      instructions_text: Type.Optional(Type.String({ description: "Inline custom instructions", maxLength: 5e4 })),
+      instructions_path: Type.Optional(Type.String({ description: "Path to instructions markdown file", maxLength: 500 })),
+      heartbeat_procedure_path: Type.Optional(Type.String({ description: "Path to heartbeat procedure markdown file", maxLength: 500 })),
+      heartbeat_interval_ms: Type.Optional(Type.Number({ description: "Heartbeat polling interval in ms", minimum: 1e3 })),
+      heartbeat_timeout_ms: Type.Optional(Type.Number({ description: "Heartbeat timeout in ms", minimum: 5e3 })),
+      max_concurrent_runs: Type.Optional(Type.Number({ description: "Max concurrent heartbeat runs", minimum: 1 })),
+      message_response_mode: Type.Optional(Type.Union([
+        Type.Literal("immediate"),
+        Type.Literal("on-heartbeat")
+      ], { description: "How agent responds to messages" }))
+    });
     sendMessageParams = Type.Object({
       to_id: Type.String({ description: "Recipient ID (agent ID or user ID, depending on message type)" }),
       content: Type.String({ description: "Message body (1-2000 characters)" }),
@@ -62085,7 +62391,8 @@ async function execWithProcessGroup(command, options) {
       cwd: options.cwd,
       shell: true,
       detached: useProcessGroup,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options.env !== void 0 && { env: { ...process.env, ...options.env } }
     });
     let stdout = "";
     let stderr = "";
@@ -62287,7 +62594,7 @@ ${footer}`;
   return parts.join("\n") + `
 ${footer}`;
 }
-async function runVerificationCommand(store, rootDir, taskId, command, type, signal, log18, agentLabel) {
+async function runVerificationCommand(store, rootDir, taskId, command, type, signal, log18, agentLabel, extraEnv) {
   const logger2 = log18 ?? { log: console.log, error: console.error, warn: console.warn };
   const label = agentLabel ?? "merger";
   if (signal?.aborted) {
@@ -62312,7 +62619,8 @@ async function runVerificationCommand(store, rootDir, taskId, command, type, sig
       cwd: rootDir,
       timeout: VERIFICATION_COMMAND_TIMEOUT_MS,
       maxBuffer: VERIFICATION_COMMAND_MAX_BUFFER,
-      signal
+      signal,
+      ...extraEnv !== void 0 && { env: extraEnv }
     });
     if (signal?.aborted) {
       throw Object.assign(
@@ -62557,7 +62865,7 @@ var init_run_audit = __esm({
 });
 
 // ../engine/src/merger.ts
-import { execSync, exec as exec3 } from "node:child_process";
+import { execSync, exec as exec3, execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 import { existsSync as existsSync24 } from "node:fs";
 import { join as join30 } from "node:path";
@@ -62689,11 +62997,51 @@ function throwIfAborted(signal, taskId) {
   if (!signal?.aborted) return;
   throw new MergeAbortedError(`Merge aborted for ${taskId}: engine shutdown requested`);
 }
+async function snapshotDirtyFiles(rootDir) {
+  const paths = /* @__PURE__ */ new Set();
+  try {
+    const [unstagedOut, stagedOut, porcelainOut] = await Promise.all([
+      execFileAsync("git", ["diff", "-z", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
+        (r) => r.stdout,
+        () => ""
+      ),
+      execFileAsync("git", ["diff", "-z", "--cached", "--name-only"], { cwd: rootDir, encoding: "utf-8" }).then(
+        (r) => r.stdout,
+        () => ""
+      ),
+      execFileAsync("git", ["status", "-z", "--porcelain"], { cwd: rootDir, encoding: "utf-8" }).then(
+        (r) => r.stdout,
+        () => ""
+      )
+    ]);
+    for (const entry of unstagedOut.split("\0")) {
+      const p = entry.trim();
+      if (p) paths.add(p);
+    }
+    for (const entry of stagedOut.split("\0")) {
+      const p = entry.trim();
+      if (p) paths.add(p);
+    }
+    for (const entry of porcelainOut.split("\0")) {
+      if (!entry.startsWith("?? ")) continue;
+      const p = entry.slice(3);
+      if (p) paths.add(p);
+    }
+  } catch {
+  }
+  return paths;
+}
 function rethrowIfMergeAborted(error) {
   if (error instanceof Error && error.name === "MergeAbortedError") {
     throw error;
   }
 }
+function execSyncText(command, options) {
+  const output = execSync(command, options);
+  if (output == null) return "";
+  if (typeof output === "string") return output.trim();
+  return output.toString("utf-8").trim();
+}
 async function runDeterministicVerification(store, rootDir, taskId, testCommand, buildCommand2, testSource, buildSource, signal) {
   const result = { allPassed: true };
   if (!testCommand && !buildCommand2) {
@@ -62704,6 +63052,35 @@ async function runDeterministicVerification(store, rootDir, taskId, testCommand,
   const normalizedBuildCommand = buildCommand2?.trim();
   const hasTestCommand = !!normalizedTestCommand;
   const hasBuildCommand = !!normalizedBuildCommand;
+  const effectiveTestCommand = normalizedTestCommand ?? "";
+  const effectiveBuildCommand = normalizedBuildCommand ?? "";
+  let treeSha = null;
+  try {
+    treeSha = execSync("git rev-parse HEAD^{tree}", { cwd: rootDir, stdio: "pipe" }).toString().trim();
+  } catch (err) {
+    mergerLog.warn(`${taskId}: could not resolve tree sha \u2014 skipping verification cache: ${String(err)}`);
+  }
+  if (treeSha) {
+    const cacheHit = store.getVerificationCacheHit(treeSha, effectiveTestCommand, effectiveBuildCommand);
+    if (cacheHit) {
+      const sha7 = treeSha.slice(0, 7);
+      const msg = `Skipping deterministic verification \u2014 cached pass for tree ${sha7} (recorded at ${cacheHit.recordedAt}, by ${cacheHit.taskId ?? "unknown"})`;
+      mergerLog.log(`${taskId}: ${msg}`);
+      await store.logEntry(taskId, msg);
+      await store.appendAgentLog(taskId, msg, "text", void 0, "merger");
+      const syntheticResult = {
+        command: "",
+        exitCode: 0,
+        stdout: "",
+        stderr: "",
+        success: true,
+        cached: true
+      };
+      if (hasTestCommand) result.testResult = { ...syntheticResult, command: effectiveTestCommand };
+      if (hasBuildCommand) result.buildResult = { ...syntheticResult, command: effectiveBuildCommand };
+      return result;
+    }
+  }
   const testSourceLabel = testSource === "inferred" ? " [inferred]" : "";
   const buildSourceLabel = buildSource === "inferred" ? " [inferred]" : "";
   mergerLog.log(
@@ -62777,13 +63154,23 @@ async function runDeterministicVerification(store, rootDir, taskId, testCommand,
   mergerLog.log(`${taskId}: deterministic verification passed`);
   await store.logEntry(taskId, "Deterministic merge verification passed");
   await store.appendAgentLog(taskId, "Deterministic merge verification passed", "text", void 0, "merger");
+  if (treeSha) {
+    try {
+      store.recordVerificationCachePass(treeSha, effectiveTestCommand, effectiveBuildCommand, taskId);
+      mergerLog.log(`${taskId}: Recorded verification pass for tree ${treeSha.slice(0, 7)}`);
+      await store.logEntry(taskId, `Recorded verification pass for tree ${treeSha.slice(0, 7)}`);
+    } catch (err) {
+      mergerLog.warn(`${taskId}: could not record verification cache pass: ${String(err)}`);
+    }
+  }
   return result;
 }
 async function runVerificationCommand2(store, rootDir, taskId, command, type, signal) {
   throwIfAborted(signal, taskId);
-  return runVerificationCommand(store, rootDir, taskId, command, type, signal, mergerLog, "merger");
+  return runVerificationCommand(store, rootDir, taskId, command, type, signal, mergerLog, "merger", VERIFICATION_EXTRA_ENV);
 }
-async function attemptInMergeVerificationFix(store, rootDir, taskId, failureContext, settings, options, mergeRunContext, fixAttemptNumber, _testCommand, _buildCommand) {
+async function attemptInMergeVerificationFix(store, rootDir, taskId, failureContext, settings, options, mergeRunContext, fixAttemptNumber, _testCommand, _buildCommand, fixModifiedFiles) {
+  const preFixSnapshot = await snapshotDirtyFiles(rootDir);
   try {
     mergerLog.log(`${taskId}: spawning in-merge verification fix agent`);
     const logger2 = new AgentLogger({
@@ -62899,6 +63286,14 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
         signal: options.signal
       });
       await accumulateSessionTokenUsage(store, taskId, session);
+      const postFixSnapshot = await snapshotDirtyFiles(rootDir);
+      if (fixModifiedFiles) {
+        for (const p of postFixSnapshot) {
+          if (!preFixSnapshot.has(p)) {
+            fixModifiedFiles.add(p);
+          }
+        }
+      }
       await store.logEntry(
         taskId,
         `Re-running deterministic merge verification (attempt ${fixAttemptNumber ?? "unknown"})`
@@ -62925,6 +63320,17 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
     }
   } catch (err) {
     rethrowIfMergeAborted(err);
+    if (fixModifiedFiles) {
+      try {
+        const postFixSnapshot = await snapshotDirtyFiles(rootDir);
+        for (const p of postFixSnapshot) {
+          if (!preFixSnapshot.has(p)) {
+            fixModifiedFiles.add(p);
+          }
+        }
+      } catch {
+      }
+    }
     const errorMessage = err instanceof Error ? err.message : String(err);
     mergerLog.warn(`${taskId}: in-merge fix agent error: ${errorMessage}`);
     await store.logEntry(taskId, "In-merge verification fix agent encountered an error", errorMessage);
@@ -63005,15 +63411,58 @@ ${trimmedDiffStat}` : ""
     bodyArg: `-m "${escape(body)}"`
   };
 }
-async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg, diffStat, settings, signal, aiSummary, aiSubject) {
+async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg, diffStat, settings, signal, aiSummary, aiSubject, fixModifiedFiles = /* @__PURE__ */ new Set()) {
   try {
-    const { stdout: unstagedFiles } = await execAsync2("git diff --name-only", {
+    const { stdout: squashStagedOut } = await execAsync2("git diff --cached --name-only", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const squashStaged = new Set(squashStagedOut.split("\n").map((l) => l.trim()).filter(Boolean));
+    const { stdout: unstagedOut } = await execAsync2("git diff --name-only", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const unstaged = new Set(unstagedOut.split("\n").map((l) => l.trim()).filter(Boolean));
+    const { stdout: porcelainOut } = await execFileAsync("git", ["status", "-z", "--porcelain"], {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    if (unstagedFiles.trim().length > 0) {
-      await execAsync2("git add -A", { cwd: rootDir });
+    const untracked = /* @__PURE__ */ new Set();
+    for (const entry of porcelainOut.split("\0")) {
+      if (!entry.startsWith("?? ")) continue;
+      const p = entry.slice(3);
+      if (p) untracked.add(p);
+    }
+    const unstagedToStage = [];
+    for (const p of unstaged) {
+      if (fixModifiedFiles.has(p)) {
+        unstagedToStage.push(p);
+      } else {
+        mergerLog.warn(
+          `${taskId}: refusing to stage unrelated working-tree change: ${p} (not part of squash or in-merge fix)`
+        );
+      }
+    }
+    if (unstagedToStage.length > 0) {
+      await execFileAsync("git", ["add", "--", ...unstagedToStage], { cwd: rootDir });
+    }
+    const untrackedToStage = [];
+    for (const p of untracked) {
+      if (fixModifiedFiles.has(p)) {
+        untrackedToStage.push(p);
+      } else {
+        mergerLog.warn(
+          `${taskId}: refusing to stage unrelated working-tree change: ${p} (not part of squash or in-merge fix)`
+        );
+      }
     }
+    if (untrackedToStage.length > 0) {
+      await execFileAsync("git", ["add", "--", ...untrackedToStage], { cwd: rootDir });
+    }
+    const cap = (arr, n = 20) => arr.length <= n ? arr.join(", ") : `${arr.slice(0, n).join(", ")} ... (+${arr.length - n} more)`;
+    mergerLog.log(
+      `${taskId}: staging allowlist \u2014 squash: [${cap([...squashStaged])}], fixModified: [${cap([...fixModifiedFiles])}]`
+    );
     const { stdout: staged } = await execAsync2("git diff --cached --raw", {
       cwd: rootDir,
       encoding: "utf-8"
@@ -63281,8 +63730,8 @@ async function classifyConflict(filePath, cwd) {
 }
 async function resolveWithOurs(filePath, cwd) {
   try {
-    await execAsync2(`git checkout --ours "${filePath}"`, { cwd });
-    await execAsync2(`git add "${filePath}"`, { cwd });
+    await execFileAsync("git", ["checkout", "--ours", "--", filePath], { cwd });
+    await execFileAsync("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} using --ours`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} with ours: ${error}`);
@@ -63290,8 +63739,8 @@ async function resolveWithOurs(filePath, cwd) {
 }
 async function resolveWithTheirs(filePath, cwd) {
   try {
-    await execAsync2(`git checkout --theirs "${filePath}"`, { cwd });
-    await execAsync2(`git add "${filePath}"`, { cwd });
+    await execFileAsync("git", ["checkout", "--theirs", "--", filePath], { cwd });
+    await execFileAsync("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} using --theirs`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} with theirs: ${error}`);
@@ -63299,7 +63748,7 @@ async function resolveWithTheirs(filePath, cwd) {
 }
 async function resolveTrivialWhitespace(filePath, cwd) {
   try {
-    await execAsync2(`git add "${filePath}"`, { cwd });
+    await execFileAsync("git", ["add", "--", filePath], { cwd });
     mergerLog.log(`Auto-resolved ${filePath} (trivial whitespace)`);
   } catch (error) {
     throw new Error(`Failed to auto-resolve ${filePath} trivial conflict: ${error}`);
@@ -63607,7 +64056,7 @@ function parsePushRemoteTarget(rootDir, pushRemote) {
   const remote = remoteToken || "origin";
   let branch = branchTokens.join(" ").trim();
   if (!branch) {
-    branch = execSync("git symbolic-ref --short HEAD", {
+    branch = execSyncText("git symbolic-ref --short HEAD", {
       cwd: rootDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -63915,7 +64364,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   } catch {
     result.error = `Branch '${branch}' not found \u2014 moving to done without merge`;
     try {
-      const commitSha = execSync("git rev-parse HEAD", {
+      const commitSha = execSyncText("git rev-parse HEAD", {
         cwd: rootDir,
         stdio: "pipe",
         encoding: "utf-8"
@@ -63938,12 +64387,12 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   }
   try {
     throwIfAborted(options.signal, taskId);
-    const currentBranch = execSync("git symbolic-ref --short HEAD", {
+    const currentBranch = execSyncText("git symbolic-ref --short HEAD", {
       cwd: rootDir,
       encoding: "utf-8",
       stdio: "pipe"
     }).trim();
-    const mainBranch = execSync("git rev-parse --abbrev-ref origin/HEAD", {
+    const mainBranch = execSyncText("git rev-parse --abbrev-ref origin/HEAD", {
       cwd: rootDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -64432,6 +64881,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           const failedType = verificationErr.verificationResult.testResult?.success === false ? "test" : "build";
           if (failedResult) {
             let fixSuccess = false;
+            const verificationFixModifiedFiles = /* @__PURE__ */ new Set();
             for (let fixAttempt = 1; fixAttempt <= maxFixRetries; fixAttempt++) {
               const fixAttemptStartedAt = Date.now();
               mergerLog.log(`${taskId}: in-merge verification fix attempt ${fixAttempt}/${maxFixRetries}`);
@@ -64459,7 +64909,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
                 { runId: mergeRunId, agentId: engineRunContext.agentId },
                 fixAttempt,
                 effectiveTestCommand,
-                effectiveBuildCommand
+                effectiveBuildCommand,
+                verificationFixModifiedFiles
               );
               const fixAttemptDurationMs = Date.now() - fixAttemptStartedAt;
               if (fixSuccess) {
@@ -64498,7 +64949,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
                 settings,
                 options.signal,
                 aiMergeSummary,
-                aiMergeSubject
+                aiMergeSubject,
+                verificationFixModifiedFiles
               );
               if (!finalized) {
                 resetMergeWithWarn(rootDir, taskId, "verification-fix finalize");
@@ -64529,6 +64981,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           const fixCommand = effectiveBuildCommand || effectiveTestCommand;
           const fixType = effectiveBuildCommand ? "build" : "test";
           let fixSuccess = false;
+          const buildFixModifiedFiles = /* @__PURE__ */ new Set();
           for (let fixAttempt = 1; fixAttempt <= maxFixRetries; fixAttempt++) {
             const fixAttemptStartedAt = Date.now();
             mergerLog.log(`${taskId}: in-merge verification fix attempt ${fixAttempt}/${maxFixRetries}`);
@@ -64556,7 +65009,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
               { runId: mergeRunId, agentId: engineRunContext.agentId },
               fixAttempt,
               effectiveTestCommand,
-              effectiveBuildCommand
+              effectiveBuildCommand,
+              buildFixModifiedFiles
             );
             const fixAttemptDurationMs = Date.now() - fixAttemptStartedAt;
             if (fixSuccess) {
@@ -64594,7 +65048,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
               settings,
               options.signal,
               aiMergeSummary,
-              aiMergeSubject
+              aiMergeSubject,
+              buildFixModifiedFiles
             );
             if (!finalized) {
               resetMergeWithWarn(rootDir, taskId, "build-verification fix finalize");
@@ -64675,7 +65130,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     throw new Error(`AI merge failed for ${taskId}: all 3 attempts exhausted`);
   }
   try {
-    const commitSha = execSync("git rev-parse HEAD", {
+    const commitSha = execSyncText("git rev-parse HEAD", {
       cwd: rootDir,
       stdio: "pipe",
       encoding: "utf-8"
@@ -64891,7 +65346,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
 async function tryFastForwardFromOrigin(rootDir, taskId) {
   let currentBranch;
   try {
-    currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+    currentBranch = execSyncText("git rev-parse --abbrev-ref HEAD", {
       cwd: rootDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -64909,7 +65364,7 @@ async function tryFastForwardFromOrigin(rootDir, taskId) {
   let behind = 0;
   let ahead = 0;
   try {
-    const counts = execSync(`git rev-list --left-right --count "origin/${currentBranch}...HEAD"`, {
+    const counts = execSyncText(`git rev-list --left-right --count "origin/${currentBranch}...HEAD"`, {
       cwd: rootDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -65048,7 +65503,7 @@ async function executeMergeAttempt(params, aiTracker) {
           }
         }
         if (complex.length === 0) {
-          const staged = execSync("git diff --cached --quiet 2>&1; echo $?", {
+          const staged = execSyncText("git diff --cached --quiet 2>&1; echo $?", {
             cwd: rootDir,
             encoding: "utf-8"
           }).trim();
@@ -65149,7 +65604,7 @@ async function executeMergeAttempt(params, aiTracker) {
         }
         return true;
       }
-      const conflictedOutput = execSync("git diff --name-only --diff-filter=U", {
+      const conflictedOutput = execSyncText("git diff --name-only --diff-filter=U", {
         cwd: rootDir,
         encoding: "utf-8"
       }).trim();
@@ -65270,7 +65725,7 @@ async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
     await execAsync2(`git merge -X ${side} --squash "${branch}"`, {
       cwd: rootDir
     });
-    const conflictedOutput = execSync("git diff --name-only --diff-filter=U", {
+    const conflictedOutput = execSyncText("git diff --name-only --diff-filter=U", {
       cwd: rootDir,
       encoding: "utf-8"
     }).trim();
@@ -65278,7 +65733,7 @@ async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
       mergerLog.warn(`${taskId}: -X ${side} left unresolved conflicts: ${conflictedOutput}`);
       return false;
     }
-    const staged = execSync("git diff --cached --quiet 2>&1; echo $?", {
+    const staged = execSyncText("git diff --cached --quiet 2>&1; echo $?", {
       cwd: rootDir,
       encoding: "utf-8"
     }).trim();
@@ -65540,7 +65995,7 @@ async function runAiAgentForCommit(params) {
       mergerLog.error(`Build verification failed for ${taskId}: ${buildErrorMessage}`);
       return { success: false, error: buildErrorMessage };
     }
-    const staged = execSync("git diff --cached --quiet 2>&1; echo $?", {
+    const staged = execSyncText("git diff --cached --quiet 2>&1; echo $?", {
       cwd: rootDir,
       encoding: "utf-8"
     }).trim();
@@ -65935,7 +66390,7 @@ async function completeTask(store, taskId, result) {
   result.task = task;
   store.emit("task:merged", result);
 }
-var execAsync2, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError, FUSION_TASK_ID_TRAILER_KEY;
+var execAsync2, execFileAsync, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError, VERIFICATION_EXTRA_ENV, FUSION_TASK_ID_TRAILER_KEY;
 var init_merger = __esm({
   "../engine/src/merger.ts"() {
     "use strict";
@@ -65955,6 +66410,7 @@ var init_merger = __esm({
     init_agent_instructions();
     init_run_audit();
     execAsync2 = promisify4(exec3);
+    execFileAsync = promisify4(execFile3);
     LOCKFILE_PATTERNS = [
       "package-lock.json",
       "pnpm-lock.yaml",
@@ -66009,6 +66465,13 @@ var init_merger = __esm({
         this.name = "MergeAbortedError";
       }
     };
+    VERIFICATION_EXTRA_ENV = Object.fromEntries(
+      [
+        ["FUSION_TEST_TOTAL_WORKERS", "8"],
+        ["FUSION_TEST_CONCURRENCY", "4"],
+        ["FUSION_TEST_WORKSPACE_CONCURRENCY", "4"]
+      ].filter(([key]) => !(key in process.env))
+    );
     FUSION_TASK_ID_TRAILER_KEY = "Fusion-Task-Id";
   }
 });
@@ -70136,7 +70599,11 @@ ${summary}`,
             // Agent delegation tools — discover and delegate work to other agents.
             ...this.options.agentStore ? [
               createListAgentsTool(this.options.agentStore),
-              createDelegateTaskTool(this.options.agentStore, this.store, { rootDir: this.rootDir })
+              createDelegateTaskTool(this.options.agentStore, this.store, { rootDir: this.rootDir }),
+              ...assignedAgentId ? [
+                createGetAgentConfigTool(this.options.agentStore, assignedAgentId),
+                createUpdateAgentConfigTool(this.options.agentStore, assignedAgentId)
+              ] : []
             ] : [],
             // Messaging tools — allows executor agents to send and receive messages.
             ...this.options.messageStore && assignedAgentId ? [
@@ -76142,6 +76609,7 @@ Your job:
 2. Do ONE useful action that changes project clarity or flow.
 3. Use fn_task_create to spawn follow-up work, fn_task_log to record observations, and fn_task_document_write for durable artifacts.
 4. Use fn_list_agents + fn_delegate_task when work should be assigned to a specific capable agent now.
+5. Use fn_get_agent_config and fn_update_agent_config to tune direct reports before delegating recurring work.
 5. Call fn_heartbeat_done when finished with an optional summary of what was accomplished.
 
 Examples of ONE useful action:
@@ -76165,6 +76633,7 @@ Use this decision rule:
 - **Task document (fn_task_document_write):** when findings are structured and likely useful across future sessions for the same task.
 - **Create task (fn_task_create):** when someone must do new executable work.
 - **Delegate task (fn_delegate_task):** when that new work should go to a specific agent based on role/availability.
+- **Manage report config (fn_get_agent_config / fn_update_agent_config):** when direct reports need heartbeat, instruction, or personality tuning.
 
 Prefer fn_task_create when assignment is unclear and scheduler routing is fine.
 Prefer fn_delegate_task when immediate ownership by a specific agent materially reduces latency or risk.
@@ -76218,6 +76687,7 @@ Your job:
 2. Do ONE useful action: analyze, create follow-up tasks, delegate work, or update memory.
 3. Use fn_task_create to spawn follow-up work.
 4. Use fn_list_agents and fn_delegate_task to coordinate with other agents.
+5. Use fn_get_agent_config and fn_update_agent_config to read/tune direct-report agents for better routing outcomes.
 5. Call fn_heartbeat_done when finished with an optional summary of what was accomplished.
 
 Examples of ONE useful action:
@@ -76231,6 +76701,7 @@ Keep work lightweight \u2014 this is a single-pass ambient check, not a full imp
 You have readonly file access plus:
 - fn_task_create
 - fn_list_agents and fn_delegate_task
+- fn_get_agent_config and fn_update_agent_config (for direct reports only)
 - fn_memory_search, fn_memory_get, and fn_memory_append
 - fn_heartbeat_done
 - fn_send_message and fn_read_messages when messaging is enabled for this run (they may not always be available)
@@ -77072,6 +77543,8 @@ not loop on the same plan across heartbeats without recording why.`;
               }, { rootDir: this.rootDir }));
               heartbeatTools.push(createListAgentsTool(this.store));
               heartbeatTools.push(createDelegateTaskTool(this.store, taskStore, { rootDir: this.rootDir }));
+              heartbeatTools.push(createGetAgentConfigTool(this.store, agentId));
+              heartbeatTools.push(createUpdateAgentConfigTool(this.store, agentId));
               if (this.messageStore) {
                 heartbeatTools.push(createSendMessageTool(this.messageStore, agentId));
                 heartbeatTools.push(createReadMessagesTool(this.messageStore, agentId));
@@ -77493,6 +77966,8 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         tools.push(createTaskDocumentReadTool(taskStore, taskId));
         tools.push(createListAgentsTool(this.store));
         tools.push(createDelegateTaskTool(this.store, taskStore, { rootDir: this.rootDir }));
+        tools.push(createGetAgentConfigTool(this.store, agentId));
+        tools.push(createUpdateAgentConfigTool(this.store, agentId));
         if (messageStore) {
           tools.push(createSendMessageTool(messageStore, agentId));
           tools.push(createReadMessagesTool(messageStore, agentId));
@@ -82343,6 +82818,11 @@ var init_in_process_runtime = __esm({
               this.recordActivity();
               runtimeLog.log(`Started executing task ${task.id} in ${worktreePath}`);
               if (this.agentStore) {
+                if (this.taskAgentMap.has(task.id)) {
+                  runtimeLog.warn(`Skipping task-worker creation for ${task.id}: agent already exists (${this.taskAgentMap.get(task.id)})`);
+                  return;
+                }
+                this.taskAgentMap.set(task.id, "creating");
                 this.agentStore.createAgent({
                   name: `executor-${task.id}`,
                   role: "executor",
@@ -82360,6 +82840,7 @@ var init_in_process_runtime = __esm({
                   await this.agentStore.updateAgentState(agent.id, "active");
                   await this.agentStore.updateAgentState(agent.id, "running");
                 }).catch((err) => {
+                  this.taskAgentMap.delete(task.id);
                   runtimeLog.warn(`Failed to create agent for task ${task.id}:`, err);
                 });
               }
@@ -84876,7 +85357,7 @@ var init_provider_adapters = __esm({
 
 // ../engine/src/remote-access/tunnel-process-manager.ts
 import { EventEmitter as EventEmitter23 } from "node:events";
-import { exec as exec10, execFile as execFile3, spawn as spawn5 } from "node:child_process";
+import { exec as exec10, execFile as execFile4, spawn as spawn5 } from "node:child_process";
 import { promisify as promisify10 } from "node:util";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -84917,7 +85398,7 @@ function toStateError(code, err) {
     at: nowIso()
   };
 }
-var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, execFileAsync, execAsync8, LineBuffer, TunnelProcessManager;
+var DEFAULT_MAX_LOG_ENTRIES, DEFAULT_STOP_TIMEOUT_MS2, execFileAsync2, execAsync8, LineBuffer, TunnelProcessManager;
 var init_tunnel_process_manager = __esm({
   "../engine/src/remote-access/tunnel-process-manager.ts"() {
     "use strict";
@@ -84925,7 +85406,7 @@ var init_tunnel_process_manager = __esm({
     init_provider_adapters();
     DEFAULT_MAX_LOG_ENTRIES = 400;
     DEFAULT_STOP_TIMEOUT_MS2 = 5e3;
-    execFileAsync = promisify10(execFile3);
+    execFileAsync2 = promisify10(execFile4);
     execAsync8 = promisify10(exec10);
     LineBuffer = class {
       pending = "";
@@ -85003,7 +85484,7 @@ var init_tunnel_process_manager = __esm({
           return null;
         }
         try {
-          const { stdout } = await execFileAsync("tailscale", ["status", "--json"], { timeout: 3e3 });
+          const { stdout } = await execFileAsync2("tailscale", ["status", "--json"], { timeout: 3e3 });
           const data = JSON.parse(String(stdout));
           const dnsName = data.Self?.DNSName?.replace(/\.$/, "");
           if (!dnsName) {
@@ -85026,7 +85507,7 @@ var init_tunnel_process_manager = __esm({
         ];
         for (const resetCommand of resetCommands) {
           try {
-            await execFileAsync(resetCommand.command, resetCommand.args, { timeout: 5e3 });
+            await execFileAsync2(resetCommand.command, resetCommand.args, { timeout: 5e3 });
             return;
           } catch {
           }
@@ -85325,7 +85806,7 @@ var init_tunnel_process_manager = __esm({
 });
 
 // ../engine/src/project-engine.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify11 } from "node:util";
 function formatErrorDetails(error) {
   if (error instanceof Error) {
@@ -85337,7 +85818,7 @@ function formatErrorDetails(error) {
   const detail = String(error);
   return { message: detail, detail };
 }
-var execFileAsync2, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
+var execFileAsync3, MERGE_HANDOFF_GRACE_MS, isRemoteActive, ProjectEngine;
 var init_project_engine = __esm({
   "../engine/src/project-engine.ts"() {
     "use strict";
@@ -85355,7 +85836,7 @@ var init_project_engine = __esm({
     init_research_orchestrator();
     init_research_step_runner();
     init_tunnel_process_manager();
-    execFileAsync2 = promisify11(execFile4);
+    execFileAsync3 = promisify11(execFile5);
     MERGE_HANDOFF_GRACE_MS = 300;
     isRemoteActive = (ra) => ra?.activeProvider != null && (ra.providers[ra.activeProvider]?.enabled ?? false);
     ProjectEngine = class _ProjectEngine {
@@ -85996,7 +86477,7 @@ ${detail}`
       async checkExecutableAvailable(command) {
         const checker = process.platform === "win32" ? "where" : "which";
         try {
-          await execFileAsync2(checker, [command]);
+          await execFileAsync3(checker, [command]);
           return { available: true };
         } catch {
           return {
@@ -86087,7 +86568,11 @@ ${detail}`
         if (this.mergeActive.has(taskId)) return;
         this.mergeActive.add(taskId);
         this.mergeQueue.push(taskId);
-        void this.drainMergeQueue();
+        void this.drainMergeQueue().catch((err) => {
+          runtimeLog.error(
+            `Merge queue drain failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
       }
       /**
        * Filter a sweep's listTasks() result to merge-eligible tasks, sort by
@@ -86609,15 +87094,19 @@ ${detail}`
             runtimeLog.warn(
               `Auto-merge periodic sweep failed: ${err instanceof Error ? err.message : String(err)}`
             );
-          }
-          if (!this.shuttingDown) {
-            const interval = await store.getSettings().then((s) => s.pollIntervalMs ?? 15e3).catch((err) => {
-              runtimeLog.warn(
-                `Auto-merge retry: failed to read pollIntervalMs, using default 15s: ${err instanceof Error ? err.message : String(err)}`
-              );
-              return 15e3;
-            });
-            this.mergeRetryTimer = setTimeout(() => void schedule(), interval);
+          } finally {
+            if (!this.shuttingDown) {
+              let interval = 15e3;
+              try {
+                const settings = await store.getSettings();
+                interval = settings.pollIntervalMs ?? 15e3;
+              } catch (err) {
+                runtimeLog.warn(
+                  `Auto-merge retry: failed to read pollIntervalMs, using default 15s: ${err instanceof Error ? err.message : String(err)}`
+                );
+              }
+              this.mergeRetryTimer = setTimeout(() => void schedule(), interval);
+            }
           }
         };
         this.mergeRetryTimer = setTimeout(() => void schedule(), 15e3);
@@ -89494,7 +89983,6 @@ function definePlugin(plugin4) {
 var init_src3 = __esm({
   "../plugin-sdk/src/index.ts"() {
     "use strict";
-    init_src();
   }
 });
 
@@ -96687,13 +97175,13 @@ var init_github_poll = __esm({
 });
 
 // ../dashboard/src/routes/resolve-diff-base.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
-var execFileAsync3;
+var execFileAsync4;
 var init_resolve_diff_base = __esm({
   "../dashboard/src/routes/resolve-diff-base.ts"() {
     "use strict";
-    execFileAsync3 = promisify12(execFile5);
+    execFileAsync4 = promisify12(execFile6);
   }
 });
 
@@ -97052,13 +97540,13 @@ var init_register_agents_projects_nodes = __esm({
 });
 
 // ../dashboard/src/exec-file.ts
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify13 } from "node:util";
-var execFileAsync4;
+var execFileAsync5;
 var init_exec_file = __esm({
   "../dashboard/src/exec-file.ts"() {
     "use strict";
-    execFileAsync4 = promisify13(execFile6);
+    execFileAsync5 = promisify13(execFile7);
   }
 });
 
@@ -97327,9 +97815,9 @@ var init_claude_cli_probe = __esm({
   }
 });
 
-// ../../plugins/fusion-plugin-droid-runtime/dist/probe.js
+// ../../plugins/fusion-plugin-droid-runtime/src/probe.ts
 var init_probe3 = __esm({
-  "../../plugins/fusion-plugin-droid-runtime/dist/probe.js"() {
+  "../../plugins/fusion-plugin-droid-runtime/src/probe.ts"() {
     "use strict";
   }
 });
@@ -97342,6 +97830,13 @@ var init_droid_cli_probe = __esm({
   }
 });
 
+// ../dashboard/src/llama-cpp-probe.ts
+var init_llama_cpp_probe = __esm({
+  "../dashboard/src/llama-cpp-probe.ts"() {
+    "use strict";
+  }
+});
+
 // ../dashboard/src/routes/register-auth-routes.ts
 var init_register_auth_routes = __esm({
   "../dashboard/src/routes/register-auth-routes.ts"() {
@@ -97349,6 +97844,7 @@ var init_register_auth_routes = __esm({
     init_src();
     init_claude_cli_probe();
     init_droid_cli_probe();
+    init_llama_cpp_probe();
     init_api_error();
     init_usage();
     init_project_store_resolver();