Run the CEO agent autonomously with a real tool-use loop

The new app reached a real LLM but never ran an agent: the kickoff task_run
sat queued forever and runTask was a single text completion with no tools.

This adds the missing runtime:
- provider-tool-turn: OpenAI Responses + Anthropic Messages tool-use turns
- agent-tools + deliverable-writer: hire_agent, create_task,
  update_task_status, write_deliverable (workspace-scoped, traversal-safe)
- agent-run-loop: real tool-use loop, capped iterations
- task-queue-worker: claims queued runs in a transaction and executes them

task-execution now drives the loop; a background worker auto-runs the
bootstrap CEO run so it hires its team, delegates tasks, and writes the first
deliverable into the bound workspace. Autonomy is gated by AGENTCOMPANY_NEW_AUTORUN
(tests run with it off to stay hermetic).

AgentCompany-New/src/main/app/task-queue-worker.ts

@@ -0,0 +1,71 @@
+import type { BrowserWindow } from "electron";
+import type { DatabaseConnection } from "../database/connection";
+import { IPC_CHANNELS } from "../../shared/ipc";
+import { TaskExecutionService } from "../services/task-execution-service";
+
+const DEFAULT_INTERVAL_MS = 5_000;
+
+export interface TaskQueueWorkerInput {
+  connection: DatabaseConnection;
+  mainWindow: BrowserWindow;
+  intervalMs?: number;
+}
+
+export interface QueuedRun {
+  id: string;
+  org_id: string;
+}
+
+/**
+ * Atomically claims the oldest queued task_run by transitioning it
+ * `queued` -> `running` in one transaction; returns the claimed run or null.
+ */
+export function claimNextQueuedRun(connection: DatabaseConnection): QueuedRun | null {
+  return connection.transaction(() => {
+    const row = connection.db
+      .prepare("select id, org_id from task_runs where state = 'queued' order by created_at asc limit 1")
+      .get() as QueuedRun | undefined;
+    if (!row) return null;
+    const result = connection.db
+      .prepare("update task_runs set state = 'running', started_at = coalesce(started_at, ?) where id = ? and state = 'queued'")
+      .run(new Date().toISOString(), row.id);
+    return result.changes === 1 ? row : null;
+  });
+}
+
+/**
+ * Autonomous executor: every tick it claims the oldest `queued` task_run (the
+ * bootstrap CEO run, plus any future heartbeat-created runs) and executes its
+ * real agent loop. The claim is a single transaction (`queued` -> `running`,
+ * verified by row changes) so a run is never executed twice.
+ */
+export function startTaskQueueWorker(input: TaskQueueWorkerInput): () => void {
+  const taskExecution = new TaskExecutionService(input.connection.db);
+  const intervalMs = input.intervalMs ?? DEFAULT_INTERVAL_MS;
+  let running = false;
+
+  const tick = async (): Promise<void> => {
+    if (running) return;
+    running = true;
+    try {
+      const claimed = claimNextQueuedRun(input.connection);
+      if (!claimed) return;
+      try {
+        await taskExecution.executeRun(claimed.org_id, claimed.id);
+      } catch {
+        // executeRun records the failure on the run row; the UI reflects it below.
+      }
+      if (!input.mainWindow.isDestroyed()) {
+        input.mainWindow.webContents.send(IPC_CHANNELS.rendererEvent, { type: "snapshot-changed" });
+      }
+    } finally {
+      running = false;
+    }
+  };
+
+  const interval = setInterval(() => {
+    void tick();
+  }, intervalMs);
+  void tick();
+  return () => clearInterval(interval);
+}