factory-ai 1.3.0 → 1.5.0

package/src/task-entry.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { AzureAgentRunner } from "./agent-runner.js";
 import { loadRegistry } from "./registry.js";
+import { createTelemetry } from "./telemetry.js";
 
 const input = await new Promise((resolve, reject) => {
   let value = "";
@@ -10,11 +11,32 @@ const input = await new Promise((resolve, reject) => {
   process.stdin.on("error", reject);
 });
 const packet = JSON.parse(input);
+const runtimeEnvironment = packet.runtimeEnvironment ?? {};
+delete packet.runtimeEnvironment;
 process.title = `factory-ai-${packet.task?.role ?? packet.mode}`.slice(0, 63);
 const registry = await loadRegistry("/opt/agent-factory/app/config/capabilities.json");
-const runner = new AzureAgentRunner({ timeoutMs: 1_800_000 }, registry);
-let result;
-if (packet.mode === "plan") result = await runner.plan(packet.objective, "/workspace");
-else if (packet.mode === "task") result = await runner.invoke({ ...packet, directory: "/workspace" });
-else throw new Error(`Unsupported task mode: ${packet.mode}`);
-process.stdout.write(`${JSON.stringify(result)}\n`);
+let currentPhase = "starting";
+const telemetry = createTelemetry({ exporter: async (record) => process.stderr.write(`@factory-event ${JSON.stringify({ type: "telemetry.recorded", telemetry: record, occurredAt: record.timestamp })}\n`) });
+const eventSink = (event) => {
+  if (event.type !== "agent.heartbeat") currentPhase = event.tool ? `${event.type}:${event.tool}` : event.type;
+  process.stderr.write(`@factory-event ${JSON.stringify({ ...event, phase: currentPhase, occurredAt: new Date().toISOString() })}\n`);
+  const kind = event.type?.startsWith("model.") ? "model" : event.type?.startsWith("tool.") ? "tool" : null;
+  if (kind) void telemetry.emitEvent(kind, { objectiveId: packet.objective.id, taskId: packet.task?.id ?? "planner0", role: packet.task?.role ?? packet.mode }, { statusClass: event.type.endsWith("failed") ? "error" : event.type.endsWith("retry") ? "retry" : "ok", attempt: event.attempt ?? event.step ?? 0, inputTokens: event.usage?.input_tokens ?? event.usage?.inputTokens, outputTokens: event.usage?.output_tokens ?? event.usage?.outputTokens });
+};
+const runner = new AzureAgentRunner({ timeoutMs: 1_800_000 }, registry, { eventSink, environment: { ...process.env, ...runtimeEnvironment } });
+const heartbeat = setInterval(() => eventSink({ type: "agent.heartbeat", role: packet.task?.role ?? packet.mode, phase: currentPhase }), 15_000);
+heartbeat.unref();
+try {
+  eventSink({ type: "agent.started", role: packet.task?.role ?? packet.mode });
+  let result;
+  if (packet.mode === "plan") result = await runner.plan(packet.objective, "/workspace", packet.context ?? []);
+  else if (packet.mode === "task") result = await runner.invoke({ ...packet, directory: "/workspace" });
+  else throw new Error(`Unsupported task mode: ${packet.mode}`);
+  eventSink({ type: "agent.completed", role: packet.task?.role ?? packet.mode });
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+} catch (error) {
+  eventSink({ type: "agent.failed", role: packet.task?.role ?? packet.mode, error: String(error.message ?? error).slice(0, 500) });
+  throw error;
+} finally {
+  clearInterval(heartbeat);
+}

package/src/task-graph.js

@@ -60,8 +60,3 @@ export function readyTasks(tasks, results) {
     .filter((task) => task.dependsOn.every((id) => results[id]?.status === "succeeded"))
     .map((task) => task.id);
 }
-
-export function applyTaskResult(state, result) {
-  if (state.results[result.taskId]) return state;
-  return { ...state, results: { ...state.results, [result.taskId]: result } };
-}

package/src/telegram-service.js

@@ -10,6 +10,7 @@ import { sendMessage } from "./bus.js";
 import { loadLocalState, loadQueueMetrics } from "./dashboard.js";
 import { formatObjectiveProgress, isAllowedChat, objectiveFromTelegram, parseTelegramCommand } from "./telegram.js";
 import { log } from "./log.js";
+import { ActivityStore } from "./activity.js";
 
 process.title = "factory-ai-telegram";
 const config = loadConfig();
@@ -37,6 +38,7 @@ const subscriptions = await loadJson(subscriptionsFile);
 const client = new ServiceBusClient(config.serviceBusFqdn, new DefaultAzureCredential());
 const sender = client.createSender(config.controlQueue);
 const abort = new AbortController();
+const activityStore = new ActivityStore(config.stateDir);
 
 async function telegram(method, body) {
   const response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
@@ -70,7 +72,7 @@ async function statusText() {
   const [{ states }, queue] = await Promise.all([loadLocalState(config.stateDir), loadQueueMetrics(config)]);
   const counts = {};
   for (const state of states) counts[state.status ?? "unknown"] = (counts[state.status ?? "unknown"] ?? 0) + 1;
-  return [`Factory AI`, `Queue: ${queue.active} active, ${queue.deadLetter} dead-letter`, `Objectives: ${Object.entries(counts).map(([name, count]) => `${name} ${count}`).join(", ") || "none"}`].join("\n");
+  return [config.factoryName, `Queue: ${queue.active} active, ${queue.deadLetter} dead-letter`, `Objectives: ${Object.entries(counts).map(([name, count]) => `${name} ${count}`).join(", ") || "none"}`].join("\n");
 }
 
 async function processUpdate(update) {
@@ -93,7 +95,8 @@ async function processUpdate(update) {
     }
     if (command.type === "objective") {
       const state = JSON.parse(await readFile(path.join(config.stateDir, command.objectiveId, "state.json"), "utf8"));
-      return reply(message.chat.id, formatObjectiveProgress(state));
+      state.activity = await activityStore.latestObjective(command.objectiveId);
+      return reply(message.chat.id, formatObjectiveProgress(state, config.factoryName));
     }
     const objective = objectiveFromTelegram(update.update_id, command);
     await sendMessage(sender, objective, objective.id);
@@ -107,14 +110,17 @@ async function processUpdate(update) {
 
 async function notifyProgress() {
   let changed = false;
+  const terminal = new Set(["complete", "failed", "blocked", "denied", "expired", "cancelled"]);
   for (const [objectiveId, subscription] of Object.entries(subscriptions)) {
     let state;
     try { state = JSON.parse(await readFile(path.join(config.stateDir, objectiveId, "state.json"), "utf8")); }
     catch (error) { if (error.code === "ENOENT") continue; throw error; }
-    const text = formatObjectiveProgress(state);
+    state.activity = await activityStore.latestObjective(objectiveId);
+    const text = formatObjectiveProgress(state, config.factoryName);
     const digest = createHash("sha256").update(text).digest("hex");
+    if (digest !== subscription.lastDigest) await reply(subscription.chatId, text);
+    if (terminal.has(state.status)) { delete subscriptions[objectiveId]; changed = true; continue; }
     if (digest === subscription.lastDigest) continue;
-    await reply(subscription.chatId, text);
     subscription.lastDigest = digest;
     subscription.lastStatus = state.status;
     subscription.notifiedAt = new Date().toISOString();

package/src/telegram.js

@@ -38,17 +38,21 @@ export function objectiveFromTelegram(updateId, command, now = new Date()) {
   };
 }
 
-export function formatObjectiveProgress(state) {
+export function formatObjectiveProgress(state, factoryName = "Factory AI") {
   const tasks = state.tasks ?? [];
   const results = state.results ?? {};
   const complete = tasks.filter((task) => results[task.id]?.status === "succeeded").length;
   const lines = [
-    `Factory AI objective ${state.objective?.id ?? "unknown"}`,
+    `${factoryName} objective ${state.objective?.id ?? "unknown"}`,
     state.objective?.objective ?? "",
     `Status: ${state.status ?? "unknown"}`,
     `${complete}/${tasks.length} tasks complete`,
   ];
-  for (const task of tasks.slice(0, 20)) lines.push(`${task.role}: ${results[task.id]?.status ?? "blocked"} — ${task.title}`);
+  for (const task of tasks.slice(0, 20)) {
+    const activity = state.activity?.[task.id];
+    const detail = activity ? ` — ${activity.phase ?? activity.type}${activity.tool ? ` ${activity.tool}` : ""}${activity.retryCount ? ` (${activity.retryCount} retries)` : ""}${activity.lastError ? ` [${activity.lastError}]` : ""}` : "";
+    lines.push(`${task.role}: ${results[task.id]?.status ?? "blocked"} — ${task.title}${detail}`);
+  }
   if (state.failure) lines.push(`Blocker: ${String(state.failure).slice(0, 500)}`);
   if (state.release?.url) lines.push(`PR: ${state.release.url}`);
   return lines.join("\n").slice(0, 4000);

package/src/telemetry.js

@@ -0,0 +1,173 @@
+import { randomBytes } from "node:crypto";
+
+export const TELEMETRY_SCHEMA_VERSION = "factory.telemetry.v1";
+
+const operationNames = Object.freeze({
+  model: "gen_ai.chat",
+  tool: "gen_ai.execute_tool",
+  queue: "factory.queue",
+  checkpoint: "factory.checkpoint",
+  scanner: "factory.scanner",
+  watchdog: "factory.watchdog",
+  release: "factory.release",
+});
+
+const aliases = Object.freeze({
+  objectiveId: "factory.objective.id",
+  taskId: "factory.task.id",
+  role: "factory.agent.role",
+  modelRoute: "gen_ai.request.model",
+  attempt: "factory.attempt",
+  toolCallId: "gen_ai.tool.call.id",
+  messageId: "messaging.message.id",
+  inputTokens: "gen_ai.usage.input_tokens",
+  outputTokens: "gen_ai.usage.output_tokens",
+  cacheReadInputTokens: "gen_ai.usage.cache_read.input_tokens",
+  durationMs: "factory.duration_ms",
+  retryCount: "factory.retry.count",
+  cacheHit: "factory.cache.hit",
+  statusClass: "factory.status.class",
+  errorCode: "error.type",
+});
+
+const identifier = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+const modelRoute = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}\/[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+const providerName = /^[a-z][a-z0-9._-]{0,63}$/;
+const errorCode = /^[a-z][a-z0-9_.-]{0,63}$/;
+const statusClasses = new Set(["ok", "error", "cancelled", "timeout", "retry"]);
+const genAiOperations = Object.freeze({ model: "chat", tool: "execute_tool" });
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+const validators = Object.freeze({
+  "factory.objective.id": (value) => typeof value === "string" && identifier.test(value),
+  "factory.task.id": (value) => typeof value === "string" && identifier.test(value),
+  "factory.agent.role": (value) => typeof value === "string" && identifier.test(value),
+  "gen_ai.request.model": (value) => typeof value === "string" && modelRoute.test(value) && !value.includes("://"),
+  "factory.attempt": nonNegativeInteger,
+  "gen_ai.tool.call.id": (value) => typeof value === "string" && identifier.test(value),
+  "messaging.message.id": (value) => typeof value === "string" && identifier.test(value),
+  "gen_ai.provider.name": (value) => typeof value === "string" && providerName.test(value),
+  "gen_ai.operation.name": (value) => value === "chat" || value === "execute_tool",
+  "gen_ai.usage.input_tokens": nonNegativeInteger,
+  "gen_ai.usage.output_tokens": nonNegativeInteger,
+  "gen_ai.usage.cache_read.input_tokens": nonNegativeInteger,
+  "factory.duration_ms": nonNegativeNumber,
+  "factory.retry.count": nonNegativeInteger,
+  "factory.cache.hit": (value) => typeof value === "boolean",
+  "factory.status.class": (value) => statusClasses.has(value),
+  "error.type": (value) => typeof value === "string" && errorCode.test(value),
+});
+
+export function safeAttributes(input = {}) {
+  const result = {};
+  if (!input || typeof input !== "object" || Array.isArray(input)) return result;
+  for (const [inputName, value] of Object.entries(input)) {
+    const name = aliases[inputName] ?? inputName;
+    if (validators[name]?.(value)) result[name] = value;
+  }
+  return result;
+}
+
+function operationName(kind) {
+  const name = operationNames[kind];
+  if (!name) throw new Error(`Unknown telemetry operation: ${kind}`);
+  return name;
+}
+
+function validHexId(value, length) {
+  return typeof value === "string" && new RegExp(`^[a-f0-9]{${length}}$`).test(value);
+}
+
+export function createTelemetry(options = {}) {
+  const {
+    exporter,
+    fallback,
+    now = Date.now,
+    createTraceId = () => randomBytes(16).toString("hex"),
+    createSpanId = () => randomBytes(8).toString("hex"),
+  } = options;
+
+  function ids(context) {
+    const traceId = validHexId(context?.traceId, 32) ? context.traceId : createTraceId();
+    const spanId = createSpanId();
+    if (!validHexId(traceId, 32) || !validHexId(spanId, 16)) throw new Error("Telemetry ID generators must return lowercase hexadecimal IDs");
+    return {
+      traceId,
+      spanId,
+      ...(validHexId(context?.parentSpanId, 16) ? { parentSpanId: context.parentSpanId } : {}),
+    };
+  }
+
+  async function deliver(record) {
+    if (typeof exporter === "function") {
+      try {
+        await exporter(record);
+        return record;
+      } catch {}
+    }
+    if (typeof fallback === "function") {
+      try { await fallback(record); } catch {}
+    }
+    return record;
+  }
+
+  function baseRecord(recordType, kind, context) {
+    const timestamp = new Date(now()).toISOString();
+    return {
+      schemaVersion: TELEMETRY_SCHEMA_VERSION,
+      recordType,
+      name: operationName(kind),
+      timestamp,
+      ...ids(context),
+    };
+  }
+
+  function startSpan(kind, context = {}, attributes = {}) {
+    const startedAt = now();
+    const base = baseRecord("span", kind, context);
+    const initialAttributes = safeAttributes({
+      ...context,
+      ...attributes,
+      ...(genAiOperations[kind] ? { "gen_ai.operation.name": genAiOperations[kind] } : {}),
+    });
+    let completion;
+    return {
+      traceId: base.traceId,
+      spanId: base.spanId,
+      end(endAttributes = {}) {
+        if (!completion) {
+          const measured = endAttributes.durationMs === undefined
+            ? { durationMs: Math.max(0, now() - startedAt), ...endAttributes }
+            : endAttributes;
+          const record = {
+            ...base,
+            attributes: { ...initialAttributes, ...safeAttributes(measured) },
+          };
+          completion = deliver(record);
+        }
+        return completion;
+      },
+    };
+  }
+
+  function emitEvent(kind, context = {}, attributes = {}) {
+    const record = {
+      ...baseRecord("event", kind, context),
+      attributes: safeAttributes({
+        ...context,
+        ...attributes,
+        ...(genAiOperations[kind] ? { "gen_ai.operation.name": genAiOperations[kind] } : {}),
+      }),
+    };
+    return deliver(record);
+  }
+
+  return Object.freeze({ startSpan, emitEvent });
+}

package/src/tui.js

@@ -5,13 +5,15 @@ import { createOperator } from "./operator.js";
 if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Factory AI UI requires an interactive terminal");
 
 const operator = createOperator();
-const screen = blessed.screen({ smartCSR: true, title: "Factory AI", fullUnicode: true, dockBorders: true });
+const factoryName = process.env.FACTORY_NAME ?? "Factory AI";
+const factoryPurpose = process.env.FACTORY_PURPOSE ?? "Ship secure reviewed software continuously";
+const screen = blessed.screen({ smartCSR: true, title: factoryName, fullUnicode: true, dockBorders: true });
 const colors = { bg: "#0d0f12", panel: "#15191f", border: "#303743", text: "#d9e0e8", muted: "#7f8b99", accent: "#78dba9", warn: "#efc46b", danger: "#ef7d7d", blue: "#77a8ff" };
 
-blessed.box({ parent: screen, top: 0, left: 0, width: "100%", height: 3, tags: true, style: { bg: colors.panel, fg: colors.text }, content: "  {bold}{#78dba9-fg}FACTORY AI{/}  {/bold}  private coding organization" });
+blessed.box({ parent: screen, top: 0, left: 0, width: "100%", height: 3, tags: true, style: { bg: colors.panel, fg: colors.text }, content: `  {bold}{#78dba9-fg}${factoryName.toUpperCase()}{/}  {/bold}  ${factoryPurpose}` });
 const menu = blessed.list({ parent: screen, top: 3, left: 0, width: 23, bottom: 2, border: { type: "line" }, label: " Navigate ", keys: true, mouse: true, vi: true, items: ["Overview", "Objectives", "Agents", "Secrets", "Capabilities", "Logs", "Settings"], style: { bg: colors.panel, fg: colors.text, border: { fg: colors.border }, selected: { bg: colors.accent, fg: "#07130d", bold: true }, item: { fg: colors.text } } });
 const main = blessed.box({ parent: screen, top: 3, left: 23, right: 0, bottom: 2, border: { type: "line" }, label: " Overview ", tags: true, scrollable: true, alwaysScroll: true, keys: true, mouse: true, vi: true, scrollbar: { ch: "▐", style: { fg: colors.accent } }, padding: { left: 2, right: 2 }, style: { bg: colors.bg, fg: colors.text, border: { fg: colors.border } } });
-const footer = blessed.box({ parent: screen, bottom: 0, left: 0, width: "100%", height: 2, tags: true, style: { bg: colors.panel, fg: colors.muted }, content: "  {bold}n{/} new objective   {bold}r{/} refresh   {bold}a{/} add secret   {bold}p/u{/} pause/resume   {bold}q{/} quit" });
+const footer = blessed.box({ parent: screen, bottom: 0, left: 0, width: "100%", height: 2, tags: true, style: { bg: colors.panel, fg: colors.muted }, content: "  {bold}n{/} new   {bold}r{/} refresh   {bold}a{/} secret   {bold}y/x{/} approve/deny   {bold}p/u{/} pause/resume   {bold}q{/} quit" });
 
 let dashboard;
 let capabilities;
@@ -20,6 +22,11 @@ let logs;
 let section = "Overview";
 let refreshing = false;
 
+function safe(value) {
+  const text = String(value ?? "").replaceAll(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+  return blessed.escape ? blessed.escape(text) : text.replaceAll("{", "\\{").replaceAll("}", "\\}");
+}
+
 function status(message, color = colors.muted) {
   footer.setContent(`  {${color}-fg}${message}{/}   {bold}n{/} new   {bold}r{/} refresh   {bold}q{/} quit`);
   screen.render();
@@ -37,20 +44,20 @@ function renderOverview() {
   const inputTokens = modelUsage.reduce((sum, item) => sum + item.inputTokens, 0);
   const cachedTokens = modelUsage.reduce((sum, item) => sum + item.cachedInputTokens, 0);
   const outputTokens = modelUsage.reduce((sum, item) => sum + item.outputTokens, 0);
-  const recent = (dashboard?.objectives ?? []).slice(-8).reverse().map((objective) => `  ${badge(objective.status.padEnd(9))}  {bold}${objective.objective}{/}\n             ${objective.repository ?? ""}`).join("\n\n");
+  const recent = (dashboard?.objectives ?? []).slice(-8).reverse().map((objective) => `  ${badge(objective.status.padEnd(9))}  {bold}${safe(objective.objective)}{/}\n             ${safe(objective.repository ?? "")}`).join("\n\n");
   main.setContent(`{bold}System{/}\n\n  Queue       {#78dba9-fg}${dashboard?.queue?.active ?? 0}{/}\n  Dead letter ${dashboard?.queue?.deadLetter ?? 0}\n  Azure MTD   {#efc46b-fg}${cost}{/}\n  Objectives  ${counts}\n  Tokens      ${inputTokens} in · ${cachedTokens} cached · ${outputTokens} out\n\n{bold}Recent objectives{/}\n\n${recent || "  No objectives yet."}`);
 }
 
 function renderObjectives() {
   main.setContent((dashboard?.objectives ?? []).slice().reverse().map((objective) => {
-    const tasks = objective.tasks.map((task) => `    ${badge(task.state.padEnd(9))} ${task.role.padEnd(9)} {#7f8b99-fg}${task.model}{/}\n               ${task.title}`).join("\n");
-    return `${badge(objective.status)} {bold}${objective.objective}{/}\n  ${objective.id}\n${tasks}${objective.pullRequest ? `\n  PR ${objective.pullRequest}` : ""}${objective.blocker ? `\n  {#ef7d7d-fg}${objective.blocker}{/}` : ""}`;
+    const tasks = objective.tasks.map((task) => `    ${badge((task.stale ? "stale" : task.state).padEnd(9))} ${task.role.padEnd(9)} {#7f8b99-fg}${safe(task.model)}{/}\n               ${safe(task.title)}${task.activity ? ` · ${safe(task.activity.type)}${task.activity.tool ? ` ${safe(task.activity.tool)}` : ""}` : ""}`).join("\n");
+    return `${badge(objective.status)} {bold}${safe(objective.objective)}{/}\n  ${safe(objective.id)}\n${tasks}${objective.pullRequest ? `\n  PR ${safe(objective.pullRequest)}` : ""}${objective.blocker ? `\n  {#ef7d7d-fg}${safe(objective.blocker)}{/}` : ""}`;
   }).join("\n\n────────────────────────────────────────────────────────\n\n") || "No objectives." );
 }
 
 function renderAgents() {
   const agents = (dashboard?.objectives ?? []).flatMap((objective) => objective.tasks.map((task) => ({ objective: objective.objective, ...task }))).filter((task) => !["succeeded"].includes(task.state));
-  main.setContent(agents.map((task) => `${badge(task.state.padEnd(9))} {bold}${task.role}{/}  ${task.model}\n  ${task.title}\n  {#7f8b99-fg}${task.objective}{/}`).join("\n\n") || "No active agents.");
+  main.setContent(agents.map((task) => `${badge((task.stale ? "stale" : task.state).padEnd(9))} {bold}${safe(task.role)}{/}  ${safe(task.model)}\n  ${safe(task.title)}\n  ${task.activity ? `${safe(task.activity.phase ?? task.activity.type)}${task.activity.tool ? ` · ${safe(task.activity.tool)}` : ""} · ${Math.round(task.activityAgeSeconds ?? 0)}s ago${task.retries ? ` · ${task.retries} retries` : ""}` : "No activity event yet"}${task.lastError ? `\n  {#ef7d7d-fg}${safe(task.lastError)}{/}` : ""}\n  {#7f8b99-fg}${safe(task.objective)}{/}`).join("\n\n") || "No active agents.");
 }
 
 function renderSecrets() {
@@ -75,7 +82,7 @@ function render() {
   else if (section === "Agents") renderAgents();
   else if (section === "Secrets") renderSecrets();
   else if (section === "Capabilities") renderCapabilities();
-  else if (section === "Logs") main.setContent(logs ?? "Loading logs...");
+  else if (section === "Logs") main.setContent(safe(logs ?? "Loading logs..."));
   else renderSettings();
   main.setScrollPerc(0);
   screen.render();
@@ -88,7 +95,7 @@ async function refresh() {
   try {
     dashboard = await operator.dashboard();
     if (section === "Capabilities" && !capabilities) capabilities = await operator.capabilities();
-    if (section === "Secrets") secrets = await operator.listSecrets();
+    if (section === "Secrets") secrets = dashboard?.secrets ?? await operator.listSecrets();
     if (section === "Logs") logs = await operator.logs();
     render();
     status(`Updated ${new Date().toLocaleTimeString()}`);
@@ -121,7 +128,19 @@ async function addSecret() {
   const value = await ask("Secret value", { secret: true });
   if (!value) return;
   status("Storing secret...");
-  try { await operator.setSecret(name, value); secrets = await operator.listSecrets(); renderSecrets(); status(`Stored ${name}`, colors.accent); } catch (error) { status(error.message, colors.danger); }
+  try {
+    await operator.setSecret(name, value);
+    secrets = [...(secrets ?? []).filter((item) => item.name !== name), { name, updated: new Date().toISOString() }].sort((left, right) => left.name.localeCompare(right.name));
+    renderSecrets();
+    status(`Stored ${name}`, colors.accent);
+  } catch (error) { status(error.message, colors.danger); }
+}
+
+async function decideApproval(decision) {
+  const objectiveId = await ask("Objective ID"); if (!objectiveId) return;
+  const approvalId = await ask("Approval ID"); if (!approvalId) return;
+  const reason = await ask(`${decision === "approved" ? "Approval" : "Denial"} reason`); if (!reason) return;
+  try { await operator.approval({ objectiveId, approvalId, decision, reason }); status(`Approval ${decision}`, decision === "approved" ? colors.accent : colors.danger); await refresh(); } catch (error) { status(error.message, colors.danger); }
 }
 
 menu.on("select", async (_, index) => { section = menu.getItem(index).getText(); render(); await refresh(); menu.focus(); });
@@ -129,6 +148,8 @@ screen.key(["q", "C-c"], () => process.exit(0));
 screen.key("r", refresh);
 screen.key("n", submitObjective);
 screen.key("a", addSecret);
+screen.key("y", () => decideApproval("approved"));
+screen.key("x", () => decideApproval("denied"));
 screen.key("p", async () => { status("Pausing workers..."); try { await operator.control("pause"); status("Workers paused", colors.warn); } catch (error) { status(error.message, colors.danger); } });
 screen.key("u", async () => { status("Resuming workers..."); try { await operator.control("resume"); status("Workers active", colors.accent); } catch (error) { status(error.message, colors.danger); } });
 screen.key("tab", () => menu.focus());

package/src/validation.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ROLES } from "./routing.js";
+import { approvalPolicies } from "./approval-policy.js";
 
 const identifier = z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/);
 const repository = z.string().url().max(2048).refine((value) => {
@@ -48,11 +49,11 @@ const taskResultSchema = z.object({
   }).optional(),
 }).strict();
 
-export const workMessageSchema = z.object({
-  type: z.literal("task"),
-  objectiveId: identifier,
-  task: taskSchema,
-}).strict();
+const scannerEvidenceSchema = z.array(z.object({
+  scanner: z.string().min(1).max(100),
+  status: z.enum(["passed", "findings", "error"]),
+  output: z.string().max(6000),
+}).strict()).max(20);
 
 const resultMessageSchema = taskResultSchema.extend({
   type: z.literal("result"),
@@ -61,6 +62,33 @@ const resultMessageSchema = taskResultSchema.extend({
   status: z.literal("succeeded"),
   commit: z.string().regex(/^[0-9a-f]{40,64}$/),
   branch: z.string().min(1).max(255).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/),
+  scannerEvidence: scannerEvidenceSchema.optional(),
+}).strict();
+
+const approvalRequestMessageSchema = z.object({
+  type: z.literal("approval_request"),
+  objectiveId: identifier,
+  approvalId: identifier,
+  policy: z.enum(approvalPolicies),
+  reason: z.string().trim().min(1).max(1000),
+  actor: z.string().trim().min(1).max(200),
+  requestedAt: z.string().datetime(),
+  expiresAt: z.string().datetime(),
+  checkpoint: z.string().min(1).max(500).optional(),
+}).strict().refine((value) => Date.parse(value.expiresAt) > Date.parse(value.requestedAt), {
+  message: "Approval expiration must follow its request time",
+  path: ["expiresAt"],
+});
+
+const approvalDecisionMessageSchema = z.object({
+  type: z.literal("approval_decision"),
+  objectiveId: identifier,
+  approvalId: identifier,
+  decision: z.enum(["approved", "denied", "expired"]),
+  actor: z.string().trim().min(1).max(200),
+  reason: z.string().trim().min(1).max(1000),
+  decidedAt: z.string().datetime(),
+  messageId: identifier,
 }).strict();
 
 export function parseObjective(value) {
@@ -71,10 +99,6 @@ export function parsePlan(value) {
   return planSchema.parse(value);
 }
 
-export function parseWorkMessage(value) {
-  return workMessageSchema.parse(value);
-}
-
 export function parseTaskResult(value) {
   return taskResultSchema.parse(value);
 }
@@ -82,3 +106,11 @@ export function parseTaskResult(value) {
 export function parseResultMessage(value) {
   return resultMessageSchema.parse(value);
 }
+
+export function parseApprovalRequestMessage(value) {
+  return approvalRequestMessageSchema.parse(value);
+}
+
+export function parseApprovalDecisionMessage(value) {
+  return approvalDecisionMessageSchema.parse(value);
+}

package/src/watchdog.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { ServiceBusClient } from "@azure/service-bus";
+import { DefaultAzureCredential } from "@azure/identity";
+import { loadConfig } from "./config.js";
+import { loadLocalState } from "./dashboard.js";
+import { sendMessage } from "./bus.js";
+import { run } from "./process.js";
+import { ActivityStore } from "./activity.js";
+import { objectiveIsTerminal } from "./objective-status.js";
+
+const TERMINAL = new Set(["complete", "failed", "blocked", "cancelled", "denied", "expired"]);
+
+export function findStaleAgents(states, now = new Date(), staleSeconds = 900) {
+  const stale = [];
+  for (const state of states) {
+    if (TERMINAL.has(state.status)) continue;
+    const tasks = state.tasks?.length ? state.tasks : state.status === "planning" ? [{ id: "planner0", role: "planner" }] : [];
+    for (const task of tasks) {
+      if (state.results?.[task.id]?.status !== "queued" && task.id !== "planner0") continue;
+      const occurredAt = state.activity?.[task.id]?.occurredAt ?? state.results?.[task.id]?.queuedAt ?? (task.id === "planner0" ? state.createdAt : undefined);
+      if (!occurredAt || now.getTime() - new Date(occurredAt).getTime() <= staleSeconds * 1000) continue;
+      stale.push({ objectiveId: state.objective.id, taskId: task.id, role: task.role, occurredAt });
+    }
+  }
+  return stale;
+}
+
+async function main() {
+  const config = loadConfig();
+  const { states } = await loadLocalState(config.stateDir);
+  const stale = findStaleAgents(states, new Date(), Number(process.env.FACTORY_WATCHDOG_STALE_SECONDS ?? 900));
+  if (stale.length === 0) return;
+  const client = new ServiceBusClient(config.serviceBusFqdn, new DefaultAzureCredential());
+  const sender = client.createSender(config.controlQueue);
+  const activityStore = new ActivityStore(config.stateDir);
+  try {
+    for (const item of stale) {
+      await activityStore.withTaskLock(item.objectiveId, item.taskId, async () => {
+        const latest = await activityStore.latestTask(item.objectiveId, item.taskId);
+        if (await objectiveIsTerminal(config.stateDir, item.objectiveId)) return;
+        if (latest?.occurredAt && latest.occurredAt !== item.occurredAt) return;
+        await sendMessage(sender, {
+          type: "failure_result",
+          objectiveId: item.objectiveId,
+          taskId: item.taskId,
+          error: `Watchdog stopped ${item.role} after no heartbeat since ${item.occurredAt}`,
+        }, `watchdog:${item.objectiveId}:${item.taskId}:${item.occurredAt}`, item.objectiveId);
+        const container = `factory-ai-${item.objectiveId}-${item.taskId}`.toLowerCase().replaceAll(/[^a-z0-9_.-]/g, "-").slice(0, 63);
+        await run("docker", ["rm", "--force", container], { allowExitCodes: [0, 1], timeoutMs: 30_000 });
+      });
+    }
+  } finally {
+    await sender.close();
+    await client.close();
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

package/src/worker.js

@@ -9,18 +9,44 @@ import { AgentExecutor } from "./agent-executor.js";
 import { sendMessage } from "./bus.js";
 import { ContainerAgentRunner } from "./container-runner.js";
 import { ScannerSuite } from "./scanner-suite.js";
+import { LocalRetriever } from "./retriever.js";
+import { ActivityStore } from "./activity.js";
+import { objectiveIsTerminal } from "./objective-status.js";
+import { evaluateApprovalPolicy } from "./approval-policy.js";
 
 process.title = "factory-ai-worker";
 const config = loadConfig();
 Object.assign(process.env, await loadRuntimeSecrets(config));
 await run("gh", ["auth", "setup-git"], { timeoutMs: 60_000 });
 const bus = createBus(config, config.agentQueue, config.controlQueue);
-const sendControl = (message) => sendMessage(bus.sender, message, `${message.objectiveId}:${message.type}:${message.taskId ?? "plan"}:v1`, message.objectiveId);
+const sendControl = (message) => sendMessage(bus.sender, message, `${message.objectiveId}:${message.type}:${message.approvalId ?? message.taskId ?? "plan"}:v1`, message.objectiveId);
+const scannerSuite = new ScannerSuite();
+async function requestApproval(input, context) {
+  if (context.message.approvalGranted) return { skipped: true };
+  const now = new Date();
+  const approvalId = `approval-${context.message.task.id}`.slice(0, 64);
+  await sendControl({ type: "approval_request", objectiveId: context.message.objectiveId, approvalId, policy: input.policy, reason: input.reason, actor: "factory-policy", requestedAt: now.toISOString(), expiresAt: input.expiresAt ?? new Date(now.getTime() + 86_400_000).toISOString(), checkpoint: context.message.task.id });
+  return { approvalId };
+}
 const executor = new AgentExecutor({
   workspaces: new WorkspaceManager(config.workspaceDir, config.timeoutMs),
-  agentRunner: new ContainerAgentRunner({ image: config.workerImage, memoryDir: config.memoryDir, timeoutMs: config.timeoutMs }),
-  scannerSuite: new ScannerSuite(),
+  agentRunner: new ContainerAgentRunner({ image: config.workerImage, memoryDir: config.memoryDir, timeoutMs: config.timeoutMs, activityStore: new ActivityStore(config.stateDir) }),
+  scannerSuite,
+  retriever: new LocalRetriever({ stateDir: config.stateDir }),
+  repoMapMaxCharacters: config.repoMapMaxCharacters,
   sendControl,
+  hooks: config.hooks,
+  hookHandlers: {
+    scanner: (input, context) => scannerSuite.scan(context.directory, { names: input.scanners }),
+    policy_check: async (input, context) => {
+      const evaluated = evaluateApprovalPolicy(Object.fromEntries(input.policies.map((policy) => [policy, new RegExp(policy.replaceAll("_", ".*"), "i").test(`${context.message.task.title} ${context.message.task.instructions}`)])));
+      if (!evaluated.required) return evaluated;
+      return { ...evaluated, ...await requestApproval({ policy: evaluated.policies[0], reason: `Policy requires approval: ${evaluated.policies.join(", ")}` }, context) };
+    },
+    notification: async (input, context) => log("info", "hook_notification", { objectiveId: context.message.objectiveId, taskId: context.message.task.id, message: input.message }),
+    snapshot: async (input) => ({ label: input.label ?? "checkpoint" }),
+    approval_request: requestApproval,
+  },
 });
 
 let shuttingDown = false;
@@ -28,6 +54,11 @@ const subscription = bus.receiver.subscribe({
   processMessage: async (message) => {
     const body = message.body;
     try {
+      if (await objectiveIsTerminal(config.stateDir, body?.objectiveId)) {
+        log("info", "terminal_objective_message_discarded", { objectiveId: body.objectiveId, taskId: body.task?.id });
+        await bus.receiver.completeMessage(message);
+        return;
+      }
       await executor.process(body);
       await bus.receiver.completeMessage(message);
     } catch (error) {