factory-ai 1.4.0 → 1.5.0

package/src/activity.js

@@ -0,0 +1,96 @@
+import { appendFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const identifier = /^[A-Za-z0-9_-]{1,64}$/;
+const terminal = new Set(["succeeded", "failed", "cancelled"]);
+
+export function isStaleActivity(activity, taskStatus, now = new Date(), staleSeconds = 120) {
+  if (!activity?.occurredAt || terminal.has(taskStatus)) return false;
+  return now.getTime() - new Date(activity.occurredAt).getTime() > staleSeconds * 1000;
+}
+
+export class ActivityStore {
+  constructor(stateRoot) {
+    this.root = path.join(stateRoot, "activity");
+    this.maxFileBytes = 5_000_000;
+  }
+
+  directory(objectiveId) {
+    if (!identifier.test(objectiveId)) throw new Error("Invalid objective activity ID");
+    return path.join(this.root, objectiveId);
+  }
+
+  async withTaskLock(objectiveId, taskId, operation) {
+    if (!identifier.test(taskId)) throw new Error("Invalid task activity ID");
+    const directory = this.directory(objectiveId);
+    await mkdir(directory, { recursive: true, mode: 0o750 });
+    const lock = path.join(directory, `${taskId}.lock`);
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+      try {
+        await mkdir(lock, { mode: 0o750 });
+        try { return await operation(); } finally { await rm(lock, { recursive: true, force: true }); }
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        try {
+          const metadata = await stat(lock);
+          if (Date.now() - metadata.mtimeMs > 30_000) { await rm(lock, { recursive: true, force: true }); continue; }
+        } catch (statError) { if (statError.code !== "ENOENT") throw statError; }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    throw new Error(`Timed out acquiring activity lock for ${taskId}`);
+  }
+
+  async append(objectiveId, taskId, event) {
+    return this.withTaskLock(objectiveId, taskId, async () => {
+      const file = path.join(this.directory(objectiveId), `${taskId}.jsonl`);
+      try {
+        const metadata = await stat(file);
+        if (metadata.size > this.maxFileBytes) {
+          const content = await readFile(file, "utf8");
+          const retained = content.slice(-Math.floor(this.maxFileBytes / 2));
+          const boundary = retained.indexOf("\n");
+          const temporary = `${file}.${process.pid}.tmp`;
+          await writeFile(temporary, boundary >= 0 ? retained.slice(boundary + 1) : retained, { mode: 0o640 });
+          await rename(temporary, file);
+        }
+      } catch (error) { if (error.code !== "ENOENT") throw error; }
+      const value = { ...event, occurredAt: event.occurredAt ?? new Date().toISOString() };
+      await appendFile(file, `${JSON.stringify(value)}\n`, { mode: 0o640 });
+      return value;
+    });
+  }
+
+  async latestTask(objectiveId, taskId) {
+    if (!identifier.test(taskId)) throw new Error("Invalid task activity ID");
+    let lines;
+    try { lines = (await readFile(path.join(this.directory(objectiveId), `${taskId}.jsonl`), "utf8")).split("\n").filter(Boolean); } catch (error) { if (error.code === "ENOENT") return undefined; throw error; }
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      try { const event = JSON.parse(lines[index]); if (event.type !== "telemetry.recorded") return event; } catch {}
+    }
+    return undefined;
+  }
+
+  async latestObjective(objectiveId) {
+    const directory = this.directory(objectiveId);
+    let files;
+    try { files = await readdir(directory); } catch (error) { if (error.code === "ENOENT") return {}; throw error; }
+    const result = {};
+    for (const file of files.filter((name) => name.endsWith(".jsonl"))) {
+      const lines = (await readFile(path.join(directory, file), "utf8")).split("\n").filter(Boolean);
+      let latest;
+      let retryCount = 0;
+      let lastError;
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          if (event.type !== "telemetry.recorded") latest = event;
+          if (event.type === "model.retry") retryCount += 1;
+          if (event.error || event.type?.endsWith(".failed")) lastError = event.error ?? event.status;
+        } catch {}
+      }
+      if (latest) result[file.slice(0, -6)] = { ...latest, retryCount, lastError };
+    }
+    return result;
+  }
+}

package/src/agent-executor.js

@@ -1,12 +1,18 @@
 import { parseTaskResult } from "./validation.js";
+import { buildRepositoryMap } from "./repo-map.js";
+import { runHooks } from "./hooks.js";
 
 export class AgentExecutor {
-  constructor({ workspaces, agentRunner, scannerSuite, retriever, sendControl }) {
+  constructor({ workspaces, agentRunner, scannerSuite, retriever, sendControl, buildRepoMap = buildRepositoryMap, repoMapMaxCharacters = 8000, hooks = [], hookHandlers = {} }) {
     this.workspaces = workspaces;
     this.agentRunner = agentRunner;
     this.scannerSuite = scannerSuite;
     this.retriever = retriever;
     this.sendControl = sendControl;
+    this.buildRepoMap = buildRepoMap;
+    this.repoMapMaxCharacters = repoMapMaxCharacters;
+    this.hooks = hooks;
+    this.hookHandlers = hookHandlers;
   }
 
   async process(message) {
@@ -17,9 +23,15 @@ export class AgentExecutor {
 
   async processPlanning(message) {
     const directory = await this.workspaces.ensureObjective(message.objective);
+    let repoMap = { text: "", entries: [] };
+    try { repoMap = await this.buildRepoMap(directory, message.objective.objective, { maxCharacters: this.repoMapMaxCharacters }); } catch {}
     let semanticContext = "";
-    try { semanticContext = this.retriever ? await this.retriever.context(directory, message.objective.repository, message.objective.objective) : ""; } catch {}
-    const context = [...(message.context ?? []), ...(semanticContext ? [{ type: "local-semantic-retrieval", content: semanticContext }] : [])];
+    try { semanticContext = this.retriever ? await this.retriever.context(directory, message.objective.repository, message.objective.objective, { repositoryEntries: repoMap.entries }) : ""; } catch {}
+    const context = [
+      ...(message.context ?? []),
+      ...(repoMap.text ? [{ type: "repository-map", content: repoMap.text }] : []),
+      ...(semanticContext ? [{ type: "local-semantic-retrieval", content: semanticContext }] : []),
+    ];
     const delivery = await this.agentRunner.plan(message.objective, directory, context);
     await this.sendControl({ type: "planning_result", objectiveId: message.objectiveId, delivery });
   }
@@ -33,14 +45,22 @@ export class AgentExecutor {
     const scannerEvidence = message.task.role === "security" && this.scannerSuite
       ? await this.scannerSuite.scan(directory)
       : [];
+    const recoveryContext = this.workspaces.recoveryContext ? await this.workspaces.recoveryContext(directory) : "";
+    let repoMap = { text: "", entries: [] };
+    if (message.task.role !== "release") {
+      const query = `${message.objective.objective}\n${message.task.title}\n${message.task.instructions}`;
+      try { repoMap = await this.buildRepoMap(directory, query, { maxCharacters: this.repoMapMaxCharacters }); } catch {}
+    }
     let semanticContext = "";
     if (message.task.role !== "release" && this.retriever) {
       const query = `${message.objective.objective}\n${message.task.title}\n${message.task.instructions}`;
-      try { semanticContext = await this.retriever.context(directory, message.objective.repository, query); } catch {}
+      try { semanticContext = await this.retriever.context(directory, message.objective.repository, query, { repositoryEntries: repoMap.entries }); } catch {}
     }
     const prompt = [
       "Execute only this assigned task, verify it, and report factual outcomes.",
+      ...(recoveryContext ? [recoveryContext] : []),
       ...(scannerEvidence.length ? [`TRUSTED SCANNER EVIDENCE (mechanical output; do not claim checks beyond this evidence):\n${JSON.stringify(scannerEvidence)}`] : []),
+      ...(repoMap.text ? [repoMap.text] : []),
       ...(semanticContext ? [`LOCAL SEMANTIC CONTEXT (retrieved from this exact repository revision):\n${semanticContext}`] : []),
     ].join("\n\n");
     const result = parseTaskResult(await this.agentRunner.invoke({
@@ -49,7 +69,20 @@ export class AgentExecutor {
       directory,
       prompt,
     }));
-    const checkpoint = await this.workspaces.checkpoint(directory, message.objective, message.task);
+    const hookResults = await runHooks(this.hooks, "before_checkpoint", this.hookHandlers, { message, directory, result });
+    for (const hook of hookResults) {
+      if (hook.action === "scanner" && hook.result.some((item) => item.status !== "passed")) throw new Error("Configured scanner hook did not pass");
+      if (hook.action === "policy_check" && hook.result.required && !hook.result.approvalId && !hook.result.skipped) throw new Error("Policy hook required approval but did not create a durable request");
+    }
+    if (hookResults.some((item) => ["approval_request", "policy_check"].includes(item.action) && item.result?.approvalId)) return;
+    const authoring = ["builder", "debugger"].includes(message.task.role);
+    if (authoring && this.scannerSuite) {
+      const secretScan = await this.scannerSuite.scan(directory, { names: ["gitleaks"] });
+      if (secretScan.some((item) => item.status !== "passed")) throw new Error("Pre-push secret scan did not pass");
+    }
+    const checkpoint = authoring
+      ? await this.workspaces.checkpoint(directory, message.objective, message.task)
+      : await this.workspaces.reference(directory, message.objective, message.task);
     await this.sendControl({
       type: "result",
       objectiveId: message.objectiveId,
@@ -57,6 +90,7 @@ export class AgentExecutor {
       status: "succeeded",
       ...result,
       ...checkpoint,
+      ...(scannerEvidence.length ? { scannerEvidence } : {}),
     });
   }
 }

package/src/agent-runner.js

@@ -5,6 +5,7 @@ import { modelForTask } from "./routing.js";
 import { createWorkspaceTools } from "./workspace-tools.js";
 import { connectMcpTools } from "./mcp-tools.js";
 import { BedrockHarness } from "./bedrock-harness.js";
+import { loadRepositoryInstructions } from "./instructions.js";
 
 function parseJson(text) {
   const fenced = text.match(/```json\s*([\s\S]*?)```/i)?.[1];
@@ -16,7 +17,9 @@ function parseJson(text) {
 }
 
 function endpointForRoute(route, role, environment) {
-  const [provider, model] = route.split("/");
+  const separator = route.indexOf("/");
+  const provider = route.slice(0, separator);
+  const model = route.slice(separator + 1);
   const lightweight = provider === "azureai-responses";
   const baseUrl = lightweight ? environment.AZURE_OPENAI_BASE_URL : environment.TEXTVED_AZURE_BASE_URL;
   const apiKey = lightweight ? environment.AZURE_OPENAI_API_KEY : environment.TEXTVED_AZURE_API_KEY;
@@ -38,48 +41,62 @@ export class AzureAgentRunner {
     environment = process.env,
     createHarness = (options) => new AzureResponsesHarness(options),
     createBedrockHarness = (options) => new BedrockHarness(options),
+    eventSink = () => {},
   } = {}) {
     this.config = config;
     this.registry = registry;
     this.environment = environment;
     this.createHarness = createHarness;
     this.createBedrockHarness = createBedrockHarness;
+    this.eventSink = eventSink;
   }
 
-  async promptForTask(objective, task, prompt, capabilities) {
+  async promptForTask(objective, task, prompt, capabilities, directory) {
     const factoryName = this.environment.FACTORY_NAME ?? "Factory AI";
     const factoryPurpose = this.environment.FACTORY_PURPOSE ?? "Ship secure reviewed software continuously";
     const skills = await Promise.all(capabilities.filter((item) => item.type === "skill").map(async (item) => (
       `ALLOWLISTED SKILL ${item.name}@${item.version}:\n${await readFile(item.path, "utf8")}`
     )));
+    const repositoryInstructions = await loadRepositoryInstructions(directory);
     return [
       `You are a ${factoryName} isolated ${task.role} subagent. Factory purpose: ${factoryPurpose}.`,
       "Work only in the assigned repository. Never inspect credentials, push Git refs, deploy, or install global tools.",
       "Use tools for evidence. Make the smallest correct change and verify every completion claim.",
       'Return only JSON: {"summary":"concise outcome","checks":["command/result"],"risks":["remaining risk"],"approval":"approved|changes_requested|not_applicable"}.',
-      ...skills,
       `CEO objective: ${objective.objective}`,
       task.instructions,
       prompt,
+      ...skills,
+      repositoryInstructions,
     ].join("\n\n");
   }
 
   harness(task, directory, additionalTools = {}) {
     const role = task.role;
     const route = modelForTask(task, this.environment);
-    const workspaceTools = createWorkspaceTools(directory);
-    if (!["builder", "debugger"].includes(role)) delete workspaceTools.write_file;
+    const workspaceTools = createWorkspaceTools(directory, { mutable: ["builder", "debugger"].includes(role), allowTests: role === "tester" });
     const tools = { ...workspaceTools, ...additionalTools };
     const budget = budgetFor(task);
+    const contextBudget = {
+      compactAfterInputTokens: Number(this.environment.FACTORY_COMPACT_AFTER_INPUT_TOKENS ?? 80_000),
+      compactMaxCharacters: Number(this.environment.FACTORY_COMPACT_MAX_CHARACTERS ?? 24_000),
+    };
     if (route.startsWith("bedrock/")) {
       return this.createBedrockHarness({
         region: this.environment.AWS_REGION ?? "us-east-1",
         model: route.slice("bedrock/".length),
+        credentials: this.environment.AWS_ACCESS_KEY_ID && this.environment.AWS_SECRET_ACCESS_KEY ? {
+          accessKeyId: this.environment.AWS_ACCESS_KEY_ID,
+          secretAccessKey: this.environment.AWS_SECRET_ACCESS_KEY,
+          ...(this.environment.AWS_SESSION_TOKEN ? { sessionToken: this.environment.AWS_SESSION_TOKEN } : {}),
+        } : undefined,
         tools,
         ...budget,
+        ...contextBudget,
+        onEvent: this.eventSink,
       });
     }
-    return this.createHarness({ ...endpointForRoute(route, role, this.environment), tools, timeoutMs: this.config.timeoutMs, ...budget });
+    return this.createHarness({ ...endpointForRoute(route, role, this.environment), tools, timeoutMs: this.config.timeoutMs, ...budget, ...contextBudget, onEvent: this.eventSink });
   }
 
   async invoke({ objective, task, directory, prompt }) {
@@ -87,9 +104,9 @@ export class AzureAgentRunner {
     const mcp = await connectMcpTools(capabilities);
     const started = Date.now();
     try {
-      const response = await this.harness(task, directory, mcp.tools).run(
-        await this.promptForTask(objective, task, prompt, capabilities),
-      );
+      const fullPrompt = await this.promptForTask(objective, task, prompt, capabilities, directory);
+      const immutableContext = `Factory safety restrictions remain authoritative.\nCEO objective: ${objective.objective}\nAssigned ${task.role} task: ${task.instructions}\n${prompt}`;
+      const response = await this.harness(task, directory, mcp.tools).run(fullPrompt, { immutableContext });
       return {
         ...parseJson(response.text),
         telemetry: {
@@ -117,6 +134,7 @@ export class AzureAgentRunner {
       ...Object.entries(this.registry.skills ?? {}),
       ...Object.entries(this.registry.mcp ?? {}),
     ].map(([name, item]) => [name, { version: item.version, roles: item.roles }]));
+    const repositoryInstructions = await loadRepositoryInstructions(directory);
     const prompt = `You are the ${this.environment.FACTORY_NAME ?? "Factory AI"} planner subagent. Factory purpose: ${this.environment.FACTORY_PURPOSE ?? "Ship secure reviewed software continuously"}. Decompose objectives into the smallest executable DAG.
 Allowed roles: scout, builder, tester, debugger, reviewer, security, release.
 Allowed capabilities: ${JSON.stringify(registrySummary)}
@@ -125,11 +143,13 @@ Return only JSON: {"executiveIntent":"...","tasks":[{"id":"...","role":"...","ti
 
 ${plannerSkills.join("\n\n")}
 
+${repositoryInstructions}
+
 Objective: ${objective.objective}
 Verified prior project context: ${JSON.stringify(projectContext).slice(0, 12000)}`;
     const mcp = await connectMcpTools(plannerCapabilities);
     try {
-      const response = await this.harness({ role: "planner", complexity: "complex" }, directory, mcp.tools).run(prompt);
+      const response = await this.harness({ role: "planner", complexity: "complex" }, directory, mcp.tools).run(prompt, { immutableContext: `Factory safety restrictions remain authoritative.\nPlanner objective: ${objective.objective}` });
       return parseJson(response.text);
     } finally {
       await mcp.close();

package/src/approval-policy.js

@@ -0,0 +1,12 @@
+export const approvalPolicies = Object.freeze([
+  "network_expansion",
+  "new_dependencies",
+  "infrastructure_changes",
+  "secret_metadata_changes",
+  "external_side_effects",
+]);
+
+export function evaluateApprovalPolicy(signals = {}) {
+  const policies = approvalPolicies.filter((policy) => signals[policy] === true);
+  return { required: policies.length > 0, policies };
+}

package/src/azure-harness.js

@@ -1,3 +1,5 @@
+import { compactCheckpoint } from "./context-compaction.js";
+
 const TRANSIENT_STATUS = new Set([408, 409, 429, 500, 502, 503, 504]);
 
 function outputText(response) {
@@ -32,6 +34,9 @@ export class AzureResponsesHarness {
     timeoutMs = 180_000,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     userAgent = `factory-ai/${process.env.FACTORY_VERSION ?? "dev"}`,
+    onEvent = () => {},
+    compactAfterInputTokens = 80_000,
+    compactMaxCharacters = 24_000,
   }) {
     this.endpoint = `${baseUrl.replace(/\/$/, "")}/responses`;
     this.apiKey = apiKey;
@@ -44,6 +49,9 @@ export class AzureResponsesHarness {
     this.timeoutMs = timeoutMs;
     this.sleep = sleep;
     this.userAgent = userAgent;
+    this.onEvent = onEvent;
+    this.compactAfterInputTokens = compactAfterInputTokens;
+    this.compactMaxCharacters = compactMaxCharacters;
   }
 
   async request(body) {
@@ -69,6 +77,7 @@ export class AzureResponsesHarness {
         if (!TRANSIENT_STATUS.has(response.status) || attempt === this.retries) {
           throw new Error(`Azure Responses HTTP ${response.status}: ${payload.error?.code ?? "request_failed"}`);
         }
+        this.onEvent({ type: "model.retry", model: this.model, attempt: attempt + 1, status: response.status });
       } catch (error) {
         const transientNetworkError = error.name === "AbortError" || error instanceof TypeError;
         if (!transientNetworkError || attempt === this.retries) throw error;
@@ -81,26 +90,34 @@ export class AzureResponsesHarness {
     throw new Error("Azure Responses retry loop exhausted");
   }
 
-  async run(prompt) {
+  async run(prompt, { immutableContext = prompt } = {}) {
     let input = prompt;
     let previousResponseId;
     const definitions = toolDefinitions(this.tools);
     const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
+    const trace = [];
     for (let step = 0; step < this.maxSteps; step += 1) {
-      const response = await this.request({
-        model: this.model,
-        input,
-        ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
-        tools: definitions,
-        max_output_tokens: this.maxOutputTokens,
-      });
+      this.onEvent({ type: "model.request.started", model: this.model, step: step + 1 });
+      let response;
+      try {
+        response = await this.request({
+          model: this.model,
+          input,
+          ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
+          tools: definitions,
+          max_output_tokens: this.maxOutputTokens,
+        });
+      } catch (error) {
+        this.onEvent({ type: "model.request.failed", model: this.model, step: step + 1, error: String(error.message ?? error).slice(0, 500) });
+        throw error;
+      }
+      this.onEvent({ type: "model.request.completed", model: this.model, step: step + 1, usage: response.usage });
       usage.inputTokens += response.usage?.input_tokens ?? 0;
       usage.cachedInputTokens += response.usage?.input_tokens_details?.cached_tokens ?? 0;
       usage.outputTokens += response.usage?.output_tokens ?? 0;
       const calls = (response.output ?? []).filter((item) => item.type === "function_call");
       if (calls.length === 0) return { text: outputText(response), responseId: response.id, steps: step + 1, usage };
-      const outputs = [];
-      for (const call of calls) {
+      const prepared = calls.map((call) => {
         const tool = this.tools[call.name];
         if (!tool) throw new Error(`Tool not allowed: ${call.name}`);
         let argumentsValue;
@@ -109,20 +126,36 @@ export class AzureResponsesHarness {
         } catch {
           throw new Error(`Invalid arguments for tool: ${call.name}`);
         }
+        return { call, tool, argumentsValue };
+      });
+      const executeCall = async ({ call, tool, argumentsValue }) => {
         let value;
         try {
+          this.onEvent({ type: "tool.started", tool: call.name, step: step + 1 });
           value = await tool.execute(argumentsValue);
+          this.onEvent({ type: "tool.completed", tool: call.name, step: step + 1 });
         } catch (error) {
+          this.onEvent({ type: "tool.failed", tool: call.name, step: step + 1, error: String(error.message ?? error).slice(0, 500) });
           value = `ERROR: ${String(error.message ?? error).slice(0, 4000)}`;
         }
-        outputs.push({
+        trace.push({ tool: call.name, output: typeof value === "string" ? value : JSON.stringify(value), status: String(value).startsWith("ERROR:") ? "error" : "success" });
+        return {
           type: "function_call_output",
           call_id: call.call_id,
           output: typeof value === "string" ? value : JSON.stringify(value),
-        });
+        };
+      };
+      const outputs = prepared.every(({ tool }) => tool.parallelSafe === true)
+        ? await Promise.all(prepared.map(executeCall))
+        : await prepared.reduce(async (pending, item) => [...await pending, await executeCall(item)], Promise.resolve([]));
+      if (this.compactAfterInputTokens > 0 && (response.usage?.input_tokens ?? 0) >= this.compactAfterInputTokens) {
+        previousResponseId = undefined;
+        input = compactCheckpoint(prompt, trace, { maxCharacters: this.compactMaxCharacters, immutableContext });
+        this.onEvent({ type: "context.compacted", model: this.model, step: step + 1, inputTokens: response.usage?.input_tokens ?? 0 });
+      } else {
+        previousResponseId = response.id;
+        input = outputs;
       }
-      previousResponseId = response.id;
-      input = outputs;
     }
     throw new Error(`Agent exceeded step limit of ${this.maxSteps}`);
   }

package/src/bedrock-harness.js

@@ -1,4 +1,5 @@
 import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
+import { compactCheckpoint } from "./context-compaction.js";
 
 function definitions(tools) {
   return Object.entries(tools).map(([name, tool]) => ({
@@ -11,24 +12,36 @@ function definitions(tools) {
 }
 
 export class BedrockHarness {
-  constructor({ client, region = process.env.AWS_REGION ?? "us-east-1", model, tools, maxSteps = 40, maxOutputTokens = 4096 }) {
-    this.client = client ?? new BedrockRuntimeClient({ region, customUserAgent: `factory-ai/${process.env.FACTORY_VERSION ?? "dev"}` });
+  constructor({ client, region = process.env.AWS_REGION ?? "us-east-1", credentials, model, tools, maxSteps = 40, maxOutputTokens = 4096, onEvent = () => {}, compactAfterInputTokens = 80_000, compactMaxCharacters = 24_000 }) {
+    this.client = client ?? new BedrockRuntimeClient({ region, credentials, customUserAgent: `factory-ai/${process.env.FACTORY_VERSION ?? "dev"}` });
     this.model = model;
     this.tools = tools;
     this.maxSteps = maxSteps;
     this.maxOutputTokens = maxOutputTokens;
+    this.onEvent = onEvent;
+    this.compactAfterInputTokens = compactAfterInputTokens;
+    this.compactMaxCharacters = compactMaxCharacters;
   }
 
-  async run(prompt) {
+  async run(prompt, { immutableContext = prompt } = {}) {
     const messages = [{ role: "user", content: [{ text: prompt }] }];
     const usage = { inputTokens: 0, outputTokens: 0 };
+    const trace = [];
     for (let step = 0; step < this.maxSteps; step += 1) {
-      const response = await this.client.send(new ConverseCommand({
-        modelId: this.model,
-        messages,
-        inferenceConfig: { maxTokens: this.maxOutputTokens },
-        ...(Object.keys(this.tools).length ? { toolConfig: { tools: definitions(this.tools) } } : {}),
-      }));
+      this.onEvent({ type: "model.request.started", model: this.model, step: step + 1 });
+      let response;
+      try {
+        response = await this.client.send(new ConverseCommand({
+          modelId: this.model,
+          messages,
+          inferenceConfig: { maxTokens: this.maxOutputTokens },
+          ...(Object.keys(this.tools).length ? { toolConfig: { tools: definitions(this.tools) } } : {}),
+        }));
+      } catch (error) {
+        this.onEvent({ type: "model.request.failed", model: this.model, step: step + 1, error: String(error.message ?? error).slice(0, 500) });
+        throw error;
+      }
+      this.onEvent({ type: "model.request.completed", model: this.model, step: step + 1, usage: response.usage });
       usage.inputTokens += response.usage?.inputTokens ?? 0;
       usage.outputTokens += response.usage?.outputTokens ?? 0;
       const message = response.output?.message;
@@ -38,16 +51,34 @@ export class BedrockHarness {
         return { text, steps: step + 1, usage };
       }
       messages.push(message);
-      const results = [];
-      for (const call of calls) {
+      const prepared = calls.map((call) => {
         const tool = this.tools[call.name];
         if (!tool) throw new Error(`Tool not allowed: ${call.name}`);
+        return { call, tool };
+      });
+      const executeCall = async ({ call, tool }) => {
         let value;
         let status = "success";
-        try { value = await tool.execute(call.input ?? {}); } catch (error) { value = `ERROR: ${String(error.message ?? error).slice(0, 4000)}`; status = "error"; }
-        results.push({ toolResult: { toolUseId: call.toolUseId, content: [{ text: typeof value === "string" ? value : JSON.stringify(value) }], status } });
-      }
+        try {
+          this.onEvent({ type: "tool.started", tool: call.name, step: step + 1 });
+          value = await tool.execute(call.input ?? {});
+          this.onEvent({ type: "tool.completed", tool: call.name, step: step + 1 });
+        } catch (error) {
+          value = `ERROR: ${String(error.message ?? error).slice(0, 4000)}`;
+          status = "error";
+          this.onEvent({ type: "tool.failed", tool: call.name, step: step + 1, error: String(error.message ?? error).slice(0, 500) });
+        }
+        trace.push({ tool: call.name, output: typeof value === "string" ? value : JSON.stringify(value), status });
+        return { toolResult: { toolUseId: call.toolUseId, content: [{ text: typeof value === "string" ? value : JSON.stringify(value) }], status } };
+      };
+      const results = prepared.every(({ tool }) => tool.parallelSafe === true)
+        ? await Promise.all(prepared.map(executeCall))
+        : await prepared.reduce(async (pending, item) => [...await pending, await executeCall(item)], Promise.resolve([]));
       messages.push({ role: "user", content: results });
+      if (this.compactAfterInputTokens > 0 && (response.usage?.inputTokens ?? 0) >= this.compactAfterInputTokens) {
+        messages.splice(0, messages.length, { role: "user", content: [{ text: compactCheckpoint(prompt, trace, { maxCharacters: this.compactMaxCharacters, immutableContext }) }] });
+        this.onEvent({ type: "context.compacted", model: this.model, step: step + 1, inputTokens: response.usage?.inputTokens ?? 0 });
+      }
     }
     throw new Error(`Agent exceeded step limit of ${this.maxSteps}`);
   }

package/src/config.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { z } from "zod";
+import { validateHooks } from "./hooks.js";
 
 const environmentSchema = z.object({
   SERVICE_BUS_NAMESPACE: z.string().min(3),
@@ -19,6 +20,9 @@ const environmentSchema = z.object({
   MAX_CONCURRENCY: z.coerce.number().int().min(1).max(3).default(3),
   TASK_TIMEOUT_MS: z.coerce.number().int().min(60_000).max(3_600_000).default(1_800_000),
   MAX_DELIVERY_COUNT: z.coerce.number().int().min(2).max(20).default(8),
+  FACTORY_WATCHDOG_STALE_SECONDS: z.coerce.number().int().min(300).max(7200).default(900),
+  FACTORY_REPO_MAP_MAX_CHARACTERS: z.coerce.number().int().min(2000).max(20_000).default(8000),
+  FACTORY_HOOKS_JSON: z.string().default("[]"),
   AZURE_PRIMARY_API_KEY_SECRET: z.string().min(1).default("azure-primary-api-key"),
   AZURE_PRIMARY_BASE_URL_SECRET: z.string().min(1).default("azure-primary-base-url"),
   AZURE_SMALL_API_KEY_SECRET: z.string().min(1).default("azure-small-api-key"),
@@ -34,6 +38,9 @@ const environmentSchema = z.object({
 export function loadConfig(environment = process.env) {
   const env = environmentSchema.parse(environment);
   if (env.CONTROL_QUEUE === env.AGENT_QUEUE) throw new Error("Control and agent queues must be different");
+  if (new Set([env.CONTROL_QUEUE, env.AGENT_QUEUE, env.RELEASE_QUEUE]).size !== 3) throw new Error("Control, agent, and release queues must be different");
+  let hooks;
+  try { hooks = validateHooks(JSON.parse(env.FACTORY_HOOKS_JSON)); } catch (error) { throw new Error(`Invalid FACTORY_HOOKS_JSON: ${error.message}`); }
   return {
     serviceBusFqdn: env.SERVICE_BUS_NAMESPACE.includes(".")
       ? env.SERVICE_BUS_NAMESPACE
@@ -67,5 +74,7 @@ export function loadConfig(environment = process.env) {
     concurrency: env.MAX_CONCURRENCY,
     timeoutMs: env.TASK_TIMEOUT_MS,
     maxDeliveryCount: env.MAX_DELIVERY_COUNT,
+    repoMapMaxCharacters: env.FACTORY_REPO_MAP_MAX_CHARACTERS,
+    hooks,
   };
 }