diff --git a/bun.lock b/bun.lock
index 7ff5834ffd..1c3f2b7f64 100644
--- a/bun.lock
+++ b/bun.lock
@@ -151,6 +151,7 @@
         "@archon/git": "workspace:*",
         "@archon/paths": "workspace:*",
         "@archon/providers": "workspace:*",
+        "@archon/symphony": "workspace:*",
         "@archon/workflows": "workspace:*",
         "@hono/zod-openapi": "^0.19.6",
         "dotenv": "^17.2.3",
@@ -167,6 +168,7 @@
       "dependencies": {
         "@archon/core": "workspace:*",
         "@archon/paths": "workspace:*",
+        "@archon/workflows": "workspace:*",
         "@octokit/rest": "^22.0.0",
         "graphql-request": "^7.2.0",
       },
diff --git a/packages/server/package.json b/packages/server/package.json
index 49cdcf3888..d3ba64d8f5 100644
--- a/packages/server/package.json
+++ b/packages/server/package.json
@@ -16,6 +16,7 @@
     "@archon/git": "workspace:*",
     "@archon/paths": "workspace:*",
     "@archon/providers": "workspace:*",
+    "@archon/symphony": "workspace:*",
     "@archon/workflows": "workspace:*",
     "@hono/zod-openapi": "^0.19.6",
     "dotenv": "^17.2.3",
diff --git a/packages/server/src/index.ts b/packages/server/src/index.ts
index ee14cfef5b..77161eb61b 100644
--- a/packages/server/src/index.ts
+++ b/packages/server/src/index.ts
@@ -63,6 +63,15 @@ import { MessagePersistence } from './adapters/web/persistence';
 import { SSETransport } from './adapters/web/transport';
 import { WorkflowEventBridge } from './adapters/web/workflow-bridge';
 import { registerApiRoutes } from './routes/api';
+import { registerSymphonyRoutes } from './routes/api.symphony';
+import {
+  startSymphonyService,
+  createProductionBridge,
+  type SymphonyServiceHandle,
+} from '@archon/symphony';
+import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { getArchonHome } from '@archon/paths';
 import {
   handleMessage,
   pool,
@@ -89,6 +98,37 @@ function getLog(): ReturnType<typeof createLogger> {
   return cachedLog;
 }
 
+/**
+ * Boot the Symphony service when `~/.archon/symphony.yaml` is present and
+ * register `/api/symphony/*` routes against the resulting handle. Missing
+ * config → silent no-op so users who don't run Symphony don't pay any cost.
+ */
+async function maybeStartSymphony(
+  app: OpenAPIHono,
+  webAdapter: WebAdapter
+): Promise<SymphonyServiceHandle | null> {
+  const configPath = join(getArchonHome(), 'symphony.yaml');
+  try {
+    await stat(configPath);
+  } catch {
+    getLog().info({ config_path: configPath }, 'symphony.disabled_no_config');
+    return null;
+  }
+  try {
+    const bridge = createProductionBridge({ webAdapter });
+    const handle = await startSymphonyService({ configPath, bridge });
+    registerSymphonyRoutes(app, handle);
+    getLog().info({ config_path: configPath }, 'symphony.routes_registered');
+    return handle;
+  } catch (err) {
+    getLog().error(
+      { err: err as Error, config_path: configPath },
+      'symphony.start_failed_continuing_without_service'
+    );
+    return null;
+  }
+}
+
 /**
  * Creates an error handler for message processing failures.
  * Logs the error and attempts to send a user-friendly message to the platform.
@@ -479,6 +519,11 @@ export async function startServer(opts: ServerOptions = {}): Promise<void> {
   // Register Web UI API routes
   registerApiRoutes(app, webAdapter, lockManager, activePlatforms);
 
+  // Optionally boot the Symphony service + register /api/symphony/* routes.
+  // Opt-in by file presence: missing ~/.archon/symphony.yaml → silent no-op.
+  const symphonyHandle = await maybeStartSymphony(app, webAdapter);
+  if (symphonyHandle) activePlatforms.push('Symphony');
+
   // GitHub webhook endpoint
   if (github) {
     app.post('/webhooks/github', async c => {
@@ -656,6 +701,16 @@ export async function startServer(opts: ServerOptions = {}): Promise<void> {
         getLog().error({ err: e }, 'shutdown_flush_failed');
       })
       .then(async () => {
+        // Stop the Symphony service first so its in-flight orchestrator
+        // promises and event-emitter subscription land before the database
+        // pool closes underneath them.
+        if (symphonyHandle) {
+          try {
+            await symphonyHandle.stop();
+          } catch (error) {
+            getLog().error({ err: error }, 'symphony_stop_error');
+          }
+        }
         // Stop adapters (these should not throw, but be defensive)
         try {
           telegram?.stop();
diff --git a/packages/server/src/routes/api.symphony.ts b/packages/server/src/routes/api.symphony.ts
new file mode 100644
index 0000000000..5cd4135d9a
--- /dev/null
+++ b/packages/server/src/routes/api.symphony.ts
@@ -0,0 +1,249 @@
+/**
+ * Symphony route registrations. Mounted only when the server boots a Symphony
+ * service (i.e. `~/.archon/symphony.yaml` exists). Routes are namespaced under
+ * `/api/symphony/*` to keep them out of the existing `/api/workflows` surface.
+ */
+import { OpenAPIHono, createRoute, z } from '@hono/zod-openapi';
+import type { Context } from 'hono';
+import type { SymphonyServiceHandle } from '@archon/symphony';
+import { listDispatches, getDispatchById } from '@archon/symphony/db/dispatches';
+import { getDatabase } from '@archon/core/db';
+import { createLogger } from '@archon/paths';
+import {
+  symphonyDispatchActionBodySchema,
+  symphonyDispatchActionResponseSchema,
+  symphonyDispatchListResponseSchema,
+  symphonyDispatchRowSchema,
+  symphonyListDispatchesQuerySchema,
+  symphonyRefreshResponseSchema,
+  symphonyStateResponseSchema,
+} from './schemas/symphony.schemas';
+import { errorSchema } from './schemas/common.schemas';
+
+let cachedLog: ReturnType<typeof createLogger> | undefined;
+function getLog(): ReturnType<typeof createLogger> {
+  if (!cachedLog) cachedLog = createLogger('api.symphony');
+  return cachedLog;
+}
+
+function jsonError(description: string): {
+  content: { 'application/json': { schema: typeof errorSchema } };
+  description: string;
+} {
+  return { content: { 'application/json': { schema: errorSchema } }, description };
+}
+
+// ---------------------------------------------------------------------------
+// Route configs
+// ---------------------------------------------------------------------------
+
+const getSymphonyStateRoute = createRoute({
+  method: 'get',
+  path: '/api/symphony/state',
+  tags: ['Symphony'],
+  summary: 'Symphony orchestrator snapshot (running, retrying, completed)',
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyStateResponseSchema } },
+      description: 'OK',
+    },
+    500: jsonError('Server error'),
+  },
+});
+
+const listSymphonyDispatchesRoute = createRoute({
+  method: 'get',
+  path: '/api/symphony/dispatches',
+  tags: ['Symphony'],
+  summary: 'List symphony_dispatches rows',
+  request: { query: symphonyListDispatchesQuerySchema },
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyDispatchListResponseSchema } },
+      description: 'OK',
+    },
+    500: jsonError('Server error'),
+  },
+});
+
+const getSymphonyDispatchRoute = createRoute({
+  method: 'get',
+  path: '/api/symphony/dispatches/{id}',
+  tags: ['Symphony'],
+  summary: 'Fetch one symphony_dispatches row by id',
+  request: { params: z.object({ id: z.string() }) },
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyDispatchRowSchema } },
+      description: 'OK',
+    },
+    404: jsonError('Not found'),
+    500: jsonError('Server error'),
+  },
+});
+
+const dispatchSymphonyRoute = createRoute({
+  method: 'post',
+  path: '/api/symphony/dispatch',
+  tags: ['Symphony'],
+  summary: 'Trigger an immediate dispatch attempt for a known dispatch_key',
+  request: {
+    body: {
+      required: true,
+      content: { 'application/json': { schema: symphonyDispatchActionBodySchema } },
+    },
+  },
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyDispatchActionResponseSchema } },
+      description: 'OK',
+    },
+    400: jsonError('Bad request'),
+    500: jsonError('Server error'),
+  },
+});
+
+const cancelSymphonyRoute = createRoute({
+  method: 'post',
+  path: '/api/symphony/cancel',
+  tags: ['Symphony'],
+  summary: 'Cancel a running Symphony dispatch and its workflow run',
+  request: {
+    body: {
+      required: true,
+      content: { 'application/json': { schema: symphonyDispatchActionBodySchema } },
+    },
+  },
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyDispatchActionResponseSchema } },
+      description: 'OK',
+    },
+    400: jsonError('Bad request'),
+    500: jsonError('Server error'),
+  },
+});
+
+const refreshSymphonyRoute = createRoute({
+  method: 'post',
+  path: '/api/symphony/refresh',
+  tags: ['Symphony'],
+  summary: 'Force the Symphony tick loop to run on the next event-loop turn',
+  responses: {
+    200: {
+      content: { 'application/json': { schema: symphonyRefreshResponseSchema } },
+      description: 'OK',
+    },
+    500: jsonError('Server error'),
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Public entry: `registerSymphonyRoutes(app, handle)`
+// ---------------------------------------------------------------------------
+
+export function registerSymphonyRoutes(app: OpenAPIHono, handle: SymphonyServiceHandle): void {
+  function jsonRes(c: Context, status: 400 | 404 | 500, message: string): Response {
+    return c.json({ error: message }, status);
+  }
+
+  function registerOpenApiRoute(
+    route: ReturnType<typeof createRoute>,
+    handler: (c: Context) => Response | Promise<Response>
+  ): void {
+    app.openapi(route, handler as never);
+  }
+
+  registerOpenApiRoute(getSymphonyStateRoute, c => {
+    try {
+      const view = handle.orchestrator.getSnapshotView();
+      return c.json(view, 200);
+    } catch (err) {
+      getLog().error({ err }, 'symphony.state_failed');
+      return jsonRes(c, 500, 'Failed to read symphony state');
+    }
+  });
+
+  registerOpenApiRoute(listSymphonyDispatchesRoute, async c => {
+    try {
+      const rawStatus = c.req.query('status');
+      const allowedStatuses = ['pending', 'running', 'completed', 'failed', 'cancelled'] as const;
+      type AllowedStatus = (typeof allowedStatuses)[number];
+      const status: AllowedStatus | undefined =
+        rawStatus && (allowedStatuses as readonly string[]).includes(rawStatus)
+          ? (rawStatus as AllowedStatus)
+          : undefined;
+      const rawLimit = c.req.query('limit');
+      const limit = rawLimit ? Math.max(1, Math.min(parseInt(rawLimit, 10), 500)) : undefined;
+      const dispatches = await listDispatches(getDatabase(), { status, limit });
+      return c.json({ dispatches }, 200);
+    } catch (err) {
+      getLog().error({ err }, 'symphony.list_dispatches_failed');
+      return jsonRes(c, 500, 'Failed to list symphony dispatches');
+    }
+  });
+
+  registerOpenApiRoute(getSymphonyDispatchRoute, async c => {
+    const id = c.req.param('id') ?? '';
+    try {
+      const row = await getDispatchById(getDatabase(), id);
+      if (!row) return jsonRes(c, 404, 'Dispatch not found');
+      return c.json(row, 200);
+    } catch (err) {
+      getLog().error({ err, id }, 'symphony.get_dispatch_failed');
+      return jsonRes(c, 500, 'Failed to get symphony dispatch');
+    }
+  });
+
+  function readDispatchKey(body: unknown): string | null {
+    if (typeof body === 'object' && body !== null) {
+      const v = (body as Record<string, unknown>).dispatch_key;
+      if (typeof v === 'string' && v.length > 0) return v;
+    }
+    return null;
+  }
+
+  registerOpenApiRoute(dispatchSymphonyRoute, async c => {
+    try {
+      const dispatchKey = readDispatchKey(await c.req.json());
+      if (!dispatchKey) {
+        return jsonRes(c, 400, 'dispatch_key required');
+      }
+      const result = await handle.orchestrator.requestImmediateDispatch(dispatchKey);
+      if (result.ok) {
+        return c.json({ ok: true, dispatch_key: result.dispatch_key }, 200);
+      }
+      return c.json({ ok: false, code: result.code, reason: result.reason }, 200);
+    } catch (err) {
+      getLog().error({ err }, 'symphony.dispatch_failed');
+      return jsonRes(c, 500, 'Failed to dispatch');
+    }
+  });
+
+  registerOpenApiRoute(cancelSymphonyRoute, async c => {
+    try {
+      const dispatchKey = readDispatchKey(await c.req.json());
+      if (!dispatchKey) {
+        return jsonRes(c, 400, 'dispatch_key required');
+      }
+      const result = handle.orchestrator.requestCancel(dispatchKey);
+      if (result.ok) {
+        return c.json({ ok: true, dispatch_key: result.dispatch_key }, 200);
+      }
+      return c.json({ ok: false, code: result.code, reason: result.reason }, 200);
+    } catch (err) {
+      getLog().error({ err }, 'symphony.cancel_failed');
+      return jsonRes(c, 500, 'Failed to cancel');
+    }
+  });
+
+  registerOpenApiRoute(refreshSymphonyRoute, c => {
+    try {
+      const result = handle.orchestrator.requestRefresh();
+      return c.json(result, 200);
+    } catch (err) {
+      getLog().error({ err }, 'symphony.refresh_failed');
+      return jsonRes(c, 500, 'Failed to refresh');
+    }
+  });
+}
diff --git a/packages/server/src/routes/schemas/symphony.schemas.ts b/packages/server/src/routes/schemas/symphony.schemas.ts
new file mode 100644
index 0000000000..4892ee6b28
--- /dev/null
+++ b/packages/server/src/routes/schemas/symphony.schemas.ts
@@ -0,0 +1,120 @@
+/**
+ * Zod schemas for the `/api/symphony/*` namespace.
+ *
+ * Symphony is the autonomous Linear+GitHub tracker dispatcher that lives in
+ * `packages/symphony` and launches Archon workflow runs per active issue.
+ * Routes are only registered when `~/.archon/symphony.yaml` exists at server
+ * startup; missing config → routes 404 silently.
+ */
+import { z } from '@hono/zod-openapi';
+
+// ---------------------------------------------------------------------------
+// Snapshot view (running / retrying / completed counts)
+// ---------------------------------------------------------------------------
+
+export const symphonyTrackerKindSchema = z
+  .enum(['linear', 'github'])
+  .openapi('SymphonyTrackerKind');
+
+export const symphonyDispatchStatusSchema = z
+  .enum(['pending', 'running', 'completed', 'failed', 'cancelled'])
+  .openapi('SymphonyDispatchStatus');
+
+export const symphonyRunningRowSchema = z
+  .object({
+    dispatch_key: z.string(),
+    tracker: symphonyTrackerKindSchema,
+    issue_id: z.string(),
+    issue_identifier: z.string(),
+    state: z.string(),
+    started_at: z.string(),
+    workflow_run_id: z.string().nullable(),
+  })
+  .openapi('SymphonyRunningRow');
+
+export const symphonyRetryRowSchema = z
+  .object({
+    dispatch_key: z.string(),
+    tracker: symphonyTrackerKindSchema,
+    issue_id: z.string(),
+    issue_identifier: z.string(),
+    attempt: z.number().int().nonnegative(),
+    due_at: z.string(),
+    error: z.string().nullable(),
+  })
+  .openapi('SymphonyRetryRow');
+
+export const symphonyStateResponseSchema = z
+  .object({
+    generated_at: z.string(),
+    counts: z.object({
+      running: z.number().int().nonnegative(),
+      retrying: z.number().int().nonnegative(),
+      completed: z.number().int().nonnegative(),
+    }),
+    running: z.array(symphonyRunningRowSchema),
+    retrying: z.array(symphonyRetryRowSchema),
+  })
+  .openapi('SymphonyStateResponse');
+
+// ---------------------------------------------------------------------------
+// Dispatch row listing (matches `symphony_dispatches` columns)
+// ---------------------------------------------------------------------------
+
+export const symphonyDispatchRowSchema = z
+  .object({
+    id: z.string(),
+    issue_id: z.string(),
+    identifier: z.string(),
+    tracker: symphonyTrackerKindSchema,
+    dispatch_key: z.string(),
+    codebase_id: z.string().nullable(),
+    workflow_name: z.string(),
+    workflow_run_id: z.string().nullable(),
+    attempt: z.number().int().nonnegative(),
+    dispatched_at: z.string(),
+    status: symphonyDispatchStatusSchema,
+    last_error: z.string().nullable(),
+  })
+  .openapi('SymphonyDispatchRow');
+
+export const symphonyDispatchListResponseSchema = z
+  .object({
+    dispatches: z.array(symphonyDispatchRowSchema),
+  })
+  .openapi('SymphonyDispatchListResponse');
+
+export const symphonyListDispatchesQuerySchema = z
+  .object({
+    status: symphonyDispatchStatusSchema.optional(),
+    limit: z.coerce.number().int().positive().max(500).optional(),
+  })
+  .openapi('SymphonyListDispatchesQuery');
+
+// ---------------------------------------------------------------------------
+// Action requests
+// ---------------------------------------------------------------------------
+
+export const symphonyDispatchActionBodySchema = z
+  .object({
+    dispatch_key: z
+      .string()
+      .min(1)
+      .describe("Source-aware dispatch key, e.g. 'linear:APP-123' or 'github:owner/repo#42'"),
+  })
+  .openapi('SymphonyDispatchActionBody');
+
+export const symphonyDispatchActionResponseSchema = z
+  .object({
+    ok: z.boolean(),
+    dispatch_key: z.string().optional(),
+    code: z.string().optional(),
+    reason: z.string().optional(),
+  })
+  .openapi('SymphonyDispatchActionResponse');
+
+export const symphonyRefreshResponseSchema = z
+  .object({
+    coalesced: z.boolean(),
+  })
+  .openapi('SymphonyRefreshResponse');
diff --git a/packages/symphony/package.json b/packages/symphony/package.json
index 9b854ed3b6..fa1408366b 100644
--- a/packages/symphony/package.json
+++ b/packages/symphony/package.json
@@ -6,7 +6,9 @@
   "types": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
-    "./db/dispatches": "./src/db/dispatches.ts"
+    "./db/dispatches": "./src/db/dispatches.ts",
+    "./workflow-bridge/factory": "./src/workflow-bridge/factory.ts",
+    "./workflow-bridge/types": "./src/workflow-bridge/types.ts"
   },
   "scripts": {
     "test": "bun test src/",
@@ -15,6 +17,7 @@
   "dependencies": {
     "@archon/core": "workspace:*",
     "@archon/paths": "workspace:*",
+    "@archon/workflows": "workspace:*",
     "@octokit/rest": "^22.0.0",
     "graphql-request": "^7.2.0"
   },
diff --git a/packages/symphony/src/db/dispatches.test.ts b/packages/symphony/src/db/dispatches.test.ts
index 8848ade2ad..2cc7457ebc 100644
--- a/packages/symphony/src/db/dispatches.test.ts
+++ b/packages/symphony/src/db/dispatches.test.ts
@@ -6,6 +6,9 @@ import {
   insertDispatch,
   getDispatchByDispatchKey,
   getDispatchById,
+  getDispatchByWorkflowRunId,
+  listDispatches,
+  listInFlight,
   updateStatus,
   attachWorkflowRun,
   type InsertDispatchInput,
@@ -203,4 +206,84 @@ describe('symphony_dispatches CRUD', () => {
     }
     expect(threw).toBe(true);
   });
+
+  test('getDispatchByWorkflowRunId looks up the dispatch row for a known run id', async () => {
+    await insertCodebase(db, 'cb-rev');
+    await insertConversation(db, 'conv-rev');
+    await insertWorkflowRun(db, 'wfr-rev', 'conv-rev');
+    const inserted = await insertDispatch(
+      db,
+      baseInput({ dispatch_key: 'linear:rev', codebase_id: 'cb-rev' })
+    );
+    await attachWorkflowRun(db, inserted.id, 'wfr-rev');
+
+    const found = await getDispatchByWorkflowRunId(db, 'wfr-rev');
+    expect(found?.id).toBe(inserted.id);
+
+    const missing = await getDispatchByWorkflowRunId(db, 'wfr-not-attached');
+    expect(missing).toBeNull();
+  });
+
+  test('listDispatches returns rows ordered by dispatched_at DESC, optionally filtered by status', async () => {
+    const a = await insertDispatch(db, baseInput({ dispatch_key: 'linear:a', status: 'pending' }));
+    // Force ordering — sqlite datetime() resolution is per-second, so insert two
+    // rows with deliberately distinct identifiers and rely on ROWID tiebreakers
+    // via the column order. We verify both rows are returned, not the exact order.
+    const b = await insertDispatch(db, baseInput({ dispatch_key: 'linear:b', status: 'failed' }));
+
+    const all = await listDispatches(db);
+    expect(all.map(r => r.dispatch_key).sort()).toEqual(['linear:a', 'linear:b']);
+
+    const failed = await listDispatches(db, { status: 'failed' });
+    expect(failed.map(r => r.id)).toEqual([b.id]);
+
+    const pending = await listDispatches(db, { status: 'pending' });
+    expect(pending.map(r => r.id)).toEqual([a.id]);
+  });
+
+  test('listInFlight returns only rows with workflow_run_id and status in (pending,running)', async () => {
+    await insertCodebase(db, 'cb-flight');
+    await insertConversation(db, 'conv-flight');
+    await insertWorkflowRun(db, 'wfr-running', 'conv-flight');
+    await insertWorkflowRun(db, 'wfr-pending', 'conv-flight');
+    await insertWorkflowRun(db, 'wfr-completed', 'conv-flight');
+
+    const running = await insertDispatch(
+      db,
+      baseInput({ dispatch_key: 'linear:running', codebase_id: 'cb-flight' })
+    );
+    await attachWorkflowRun(db, running.id, 'wfr-running');
+    await updateStatus(db, running.id, 'running');
+
+    const pending = await insertDispatch(
+      db,
+      baseInput({ dispatch_key: 'linear:pending', codebase_id: 'cb-flight' })
+    );
+    await attachWorkflowRun(db, pending.id, 'wfr-pending');
+    // status stays 'pending'
+
+    const completed = await insertDispatch(
+      db,
+      baseInput({ dispatch_key: 'linear:completed', codebase_id: 'cb-flight' })
+    );
+    await attachWorkflowRun(db, completed.id, 'wfr-completed');
+    await updateStatus(db, completed.id, 'completed');
+
+    // failed-no-run rows must NOT show up (they never launched a workflow)
+    await insertDispatch(
+      db,
+      baseInput({
+        dispatch_key: 'linear:no-codebase',
+        status: 'failed',
+        last_error: 'no codebase mapped',
+      })
+    );
+
+    const inFlight = await listInFlight(db);
+    const ids = new Set(inFlight.map(r => r.id));
+    expect(ids.has(running.id)).toBe(true);
+    expect(ids.has(pending.id)).toBe(true);
+    expect(ids.has(completed.id)).toBe(false);
+    expect(inFlight.length).toBe(2);
+  });
 });
diff --git a/packages/symphony/src/db/dispatches.ts b/packages/symphony/src/db/dispatches.ts
index 2ec87b27d8..05f75df2c6 100644
--- a/packages/symphony/src/db/dispatches.ts
+++ b/packages/symphony/src/db/dispatches.ts
@@ -97,6 +97,60 @@ export async function getDispatchById(db: IDatabase, id: string): Promise<Dispat
   return result.rows[0] ?? null;
 }
 
+export async function getDispatchByWorkflowRunId(
+  db: IDatabase,
+  workflowRunId: string
+): Promise<DispatchRow | null> {
+  const result = await db.query<DispatchRow>(
+    'SELECT * FROM symphony_dispatches WHERE workflow_run_id = $1',
+    [workflowRunId]
+  );
+  return result.rows[0] ?? null;
+}
+
+export interface ListDispatchesOptions {
+  status?: DispatchStatus;
+  limit?: number;
+}
+
+export async function listDispatches(
+  db: IDatabase,
+  opts: ListDispatchesOptions = {}
+): Promise<DispatchRow[]> {
+  const limit = Math.max(1, Math.min(opts.limit ?? 100, 500));
+  if (opts.status) {
+    const result = await db.query<DispatchRow>(
+      'SELECT * FROM symphony_dispatches WHERE status = $1 ORDER BY dispatched_at DESC LIMIT $2',
+      [opts.status, limit]
+    );
+    return [...result.rows];
+  }
+  const result = await db.query<DispatchRow>(
+    'SELECT * FROM symphony_dispatches ORDER BY dispatched_at DESC LIMIT $1',
+    [limit]
+  );
+  return [...result.rows];
+}
+
+/**
+ * Rows that may correspond to a still-running upstream workflow_run. Used by
+ * the orchestrator's reconcileOnStart() to recover from a process crash.
+ *
+ * Excludes rows with workflow_run_id = NULL because they never actually
+ * launched a workflow (e.g. failed at the codebase-mapping gate). Includes
+ * 'pending' because executeWorkflow may not have transitioned the run yet
+ * when the parent process died.
+ */
+export async function listInFlight(db: IDatabase): Promise<DispatchRow[]> {
+  const result = await db.query<DispatchRow>(
+    `SELECT * FROM symphony_dispatches
+     WHERE workflow_run_id IS NOT NULL
+       AND status IN ('pending', 'running')
+     ORDER BY dispatched_at DESC`
+  );
+  return [...result.rows];
+}
+
 export async function updateStatus(
   db: IDatabase,
   id: string,
diff --git a/packages/symphony/src/index.ts b/packages/symphony/src/index.ts
index 1bf0bd5cb5..901ae06133 100644
--- a/packages/symphony/src/index.ts
+++ b/packages/symphony/src/index.ts
@@ -54,3 +54,25 @@ export {
   type StartSymphonyServiceOptions,
   type SymphonyServiceHandle,
 } from './service';
+export { createProductionBridge } from './workflow-bridge/factory';
+export type {
+  BridgeCodebase,
+  BridgeConversation,
+  BridgeDeps,
+  BridgeWebAdapter,
+  CodebaseLoader,
+  DispatchInput,
+  DispatchOutcome,
+  IsolationResolver,
+  RunWorkflowFn,
+  RunWorkflowInput,
+  WorkerConversationFactory,
+  WorkflowResolver,
+} from './workflow-bridge/types';
+export {
+  listDispatches,
+  listInFlight,
+  getDispatchByDispatchKey,
+  getDispatchById,
+  getDispatchByWorkflowRunId,
+} from './db/dispatches';
diff --git a/packages/symphony/src/orchestrator/dispatch-loop.test.ts b/packages/symphony/src/orchestrator/dispatch-loop.test.ts
index 32c02bca0e..16ffbccd12 100644
--- a/packages/symphony/src/orchestrator/dispatch-loop.test.ts
+++ b/packages/symphony/src/orchestrator/dispatch-loop.test.ts
@@ -5,6 +5,7 @@ import { SqliteAdapter } from '@archon/core/db/adapters/sqlite';
 import { Orchestrator } from './orchestrator';
 import { buildSnapshot, type ConfigSnapshot } from '../config/snapshot';
 import { makeFakeTracker, makeIssue } from '../test/fake-tracker';
+import { makeFakeBridge, makeFakeWorkflowDefinition, type FakeBridge } from '../test/fake-bridge';
 import { getDispatchByDispatchKey } from '../db/dispatches';
 import { buildDispatchKey } from './state';
 
@@ -16,6 +17,7 @@ function buildLinearOnlySnapshot(env: NodeJS.ProcessEnv = { K: 'tok' }): ConfigS
           kind: 'linear',
           api_key: '$K',
           project_slug: 'sandbox',
+          repository: 'Ddell12/archon-symphony-smoke-test',
           active_states: ['Todo', 'In Progress'],
           terminal_states: ['Done', 'Canceled'],
         },
@@ -26,7 +28,13 @@ function buildLinearOnlySnapshot(env: NodeJS.ProcessEnv = { K: 'tok' }): ConfigS
         Todo: 'archon-feature-development',
         'In Progress': 'archon-continue',
       },
-      codebases: [],
+      codebases: [
+        {
+          tracker: 'linear',
+          repository: 'Ddell12/archon-symphony-smoke-test',
+          codebase_id: 'cb-l',
+        },
+      ],
     },
     env
   );
@@ -34,14 +42,31 @@ function buildLinearOnlySnapshot(env: NodeJS.ProcessEnv = { K: 'tok' }): ConfigS
 
 let dbPath = '';
 let db: SqliteAdapter;
+let fakeBridge: FakeBridge;
 
-describe('orchestrator dispatch loop (Phase 2 stub)', () => {
-  beforeEach(() => {
+describe('orchestrator dispatch loop', () => {
+  beforeEach(async () => {
     dbPath = join(
       import.meta.dir,
       `.test-disploop-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
     );
     db = new SqliteAdapter(dbPath);
+    // FK seed: symphony_dispatches.codebase_id needs a real codebase row.
+    await db.query(
+      'INSERT INTO remote_agent_codebases (id, name, default_cwd) VALUES ($1, $2, $3)',
+      ['cb-l', 'Linear codebase', '/tmp/cb-l']
+    );
+    const codebases = new Map([
+      ['cb-l', { id: 'cb-l', name: 'Linear codebase', default_cwd: '/tmp/cb-l' }],
+    ]);
+    fakeBridge = makeFakeBridge({
+      db,
+      codebases,
+      workflows: {
+        'archon-feature-development': makeFakeWorkflowDefinition('archon-feature-development'),
+        'archon-continue': makeFakeWorkflowDefinition('archon-continue'),
+      },
+    });
   });
 
   afterEach(async () => {
@@ -65,6 +90,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
       getSnapshot: () => snapshot,
       trackers: { linear: tracker },
       getDb: () => db,
+      bridge: fakeBridge.bridge,
       // never auto-reschedule — we drive ticks manually so the test stays
       // deterministic and we don't burn into the next polling interval.
       scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
@@ -77,17 +103,21 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
     const rowB = await getDispatchByDispatchKey(db, buildDispatchKey('linear', 'APP-2'));
     expect(rowA).not.toBeNull();
     expect(rowB).not.toBeNull();
-    expect(rowA?.workflow_run_id).toBeNull();
+    expect(rowA?.workflow_run_id).toBeTruthy();
     expect(rowA?.workflow_name).toBe('archon-feature-development');
     expect(rowB?.workflow_name).toBe('archon-continue');
-    expect(rowA?.status).toBe('pending');
-
-    expect(orch.internalState.completed.has(buildDispatchKey('linear', 'APP-1'))).toBe(true);
-    expect(orch.internalState.completed.has(buildDispatchKey('linear', 'APP-2'))).toBe(true);
-    expect(orch.internalState.running.size).toBe(0);
+    expect(rowA?.status).toBe('running');
+    expect(rowB?.status).toBe('running');
+
+    // Both ended up in `running` (with workflow_run_id) — terminal events
+    // would later move them to `completed`.
+    expect(orch.internalState.running.has(buildDispatchKey('linear', 'APP-1'))).toBe(true);
+    expect(orch.internalState.running.has(buildDispatchKey('linear', 'APP-2'))).toBe(true);
+    expect(orch.internalState.completed.size).toBe(0);
+    expect(fakeBridge.runs.length).toBe(2);
   });
 
-  test('next tick does not re-dispatch already-completed dispatch_keys', async () => {
+  test('next tick does not re-dispatch already-running dispatch_keys', async () => {
     const snapshot = buildLinearOnlySnapshot();
     const issue = makeIssue({ id: 'lin-x', identifier: 'APP-X', state: 'Todo' });
     const { tracker, controls } = makeFakeTracker([issue]);
@@ -96,6 +126,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
       getSnapshot: () => snapshot,
       trackers: { linear: tracker },
       getDb: () => db,
+      bridge: fakeBridge.bridge,
       scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
       cancelTimeout: () => undefined,
     });
@@ -108,7 +139,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
 
     await orch.runTick();
     expect(controls.candidateCalls).toBeGreaterThan(firstCallCount);
-    // Still exactly one dispatch row — the eligibility "completed" gate
+    // Still exactly one dispatch row — the eligibility "running" gate
     // prevented a second insert (which would have hit the UNIQUE constraint
     // and surfaced as a dispatch_db_conflict log line).
     const all = await db.query<{ count: number }>(
@@ -116,6 +147,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
       [dispatchKey]
     );
     expect(all.rows[0]?.count).toBe(1);
+    expect(fakeBridge.runs.length).toBe(1);
   });
 
   test('skips dispatch when state has no workflow mapping', async () => {
@@ -126,6 +158,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
             kind: 'linear',
             api_key: '$K',
             project_slug: 'sandbox',
+            repository: 'Ddell12/archon-symphony-smoke-test',
             active_states: ['Todo'],
             terminal_states: ['Done'],
           },
@@ -133,7 +166,13 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
         dispatch: { max_concurrent: 5 },
         polling: { interval_ms: 30_000 },
         state_workflow_map: {}, // empty — no mapping
-        codebases: [],
+        codebases: [
+          {
+            tracker: 'linear',
+            repository: 'Ddell12/archon-symphony-smoke-test',
+            codebase_id: 'cb-l',
+          },
+        ],
       },
       { K: 'tok' } as NodeJS.ProcessEnv
     );
@@ -144,6 +183,7 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
       getSnapshot: () => snapshot,
       trackers: { linear: tracker },
       getDb: () => db,
+      bridge: fakeBridge.bridge,
       scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
       cancelTimeout: () => undefined,
     });
@@ -152,8 +192,58 @@ describe('orchestrator dispatch loop (Phase 2 stub)', () => {
 
     const row = await getDispatchByDispatchKey(db, buildDispatchKey('linear', 'APP-NO'));
     expect(row).toBeNull();
-    // Not added to completed either — a config fix could make it eligible.
-    expect(orch.internalState.completed.has(buildDispatchKey('linear', 'APP-NO'))).toBe(false);
+    // Dispatcher returned `failed_no_workflow` BEFORE inserting any row, so
+    // the orchestrator marks the key completed (no retry — config error).
+    expect(orch.internalState.completed.has(buildDispatchKey('linear', 'APP-NO'))).toBe(true);
     expect(orch.internalState.claimed.has(buildDispatchKey('linear', 'APP-NO'))).toBe(false);
+    expect(orch.internalState.running.has(buildDispatchKey('linear', 'APP-NO'))).toBe(false);
+    expect(fakeBridge.runs.length).toBe(0);
+  });
+
+  test('hard-fails dispatch when codebase is not mapped (writes failed row)', async () => {
+    // No codebase mapping for the linear tracker → orchestrator passes
+    // codebaseId=null → dispatcher writes a failed row, no run.
+    const snapshot = buildSnapshot(
+      {
+        trackers: [
+          {
+            kind: 'linear',
+            api_key: '$K',
+            project_slug: 'sandbox',
+            repository: 'Ddell12/archon-symphony-smoke-test',
+            active_states: ['Todo'],
+            terminal_states: ['Done'],
+          },
+        ],
+        dispatch: { max_concurrent: 5 },
+        polling: { interval_ms: 30_000 },
+        state_workflow_map: { Todo: 'archon-feature-development' },
+        codebases: [],
+      },
+      { K: 'tok' } as NodeJS.ProcessEnv
+    );
+    const issue = makeIssue({ id: 'lin-c', identifier: 'APP-C', state: 'Todo' });
+    const { tracker } = makeFakeTracker([issue]);
+
+    const orch = new Orchestrator({
+      getSnapshot: () => snapshot,
+      trackers: { linear: tracker },
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+
+    await orch.runTick();
+
+    const dispatchKey = buildDispatchKey('linear', 'APP-C');
+    const row = await getDispatchByDispatchKey(db, dispatchKey);
+    expect(row).not.toBeNull();
+    expect(row?.status).toBe('failed');
+    expect(row?.codebase_id).toBeNull();
+    expect(row?.workflow_run_id).toBeNull();
+    expect(row?.last_error).toContain('no codebase mapped');
+    expect(orch.internalState.completed.has(dispatchKey)).toBe(true);
+    expect(fakeBridge.runs.length).toBe(0);
   });
 });
diff --git a/packages/symphony/src/orchestrator/dispatch.test.ts b/packages/symphony/src/orchestrator/dispatch.test.ts
index ed9f64c17e..187350819a 100644
--- a/packages/symphony/src/orchestrator/dispatch.test.ts
+++ b/packages/symphony/src/orchestrator/dispatch.test.ts
@@ -59,6 +59,8 @@ function makeRunningEntry(id: string): RunningEntry {
     retry_attempt: null,
     abort: new AbortController(),
     cancel_requested: false,
+    dispatch_id: null,
+    workflow_run_id: null,
   };
 }
 
diff --git a/packages/symphony/src/orchestrator/multi-tracker.test.ts b/packages/symphony/src/orchestrator/multi-tracker.test.ts
index a9f6665b58..47c615f1f2 100644
--- a/packages/symphony/src/orchestrator/multi-tracker.test.ts
+++ b/packages/symphony/src/orchestrator/multi-tracker.test.ts
@@ -5,19 +5,43 @@ import { SqliteAdapter } from '@archon/core/db/adapters/sqlite';
 import { Orchestrator } from './orchestrator';
 import { buildSnapshot } from '../config/snapshot';
 import { makeFakeTracker, makeIssue } from '../test/fake-tracker';
+import { makeFakeBridge, makeFakeWorkflowDefinition, type FakeBridge } from '../test/fake-bridge';
 import { getDispatchByDispatchKey } from '../db/dispatches';
 import { buildDispatchKey } from './state';
 
 let dbPath = '';
 let db: SqliteAdapter;
+let fakeBridge: FakeBridge;
+
+async function seedCodebase(id: string, name: string): Promise<void> {
+  await db.query('INSERT INTO remote_agent_codebases (id, name, default_cwd) VALUES ($1, $2, $3)', [
+    id,
+    name,
+    `/tmp/${id}`,
+  ]);
+}
 
 describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     dbPath = join(
       import.meta.dir,
       `.test-multi-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
     );
     db = new SqliteAdapter(dbPath);
+    // The symphony_dispatches.codebase_id FK requires real rows.
+    await seedCodebase('cb-l', 'Linear codebase');
+    await seedCodebase('cb-gh', 'GitHub codebase');
+    const codebases = new Map([
+      ['cb-l', { id: 'cb-l', name: 'Linear codebase', default_cwd: '/tmp/cb-l' }],
+      ['cb-gh', { id: 'cb-gh', name: 'GitHub codebase', default_cwd: '/tmp/cb-gh' }],
+    ]);
+    fakeBridge = makeFakeBridge({
+      db,
+      codebases,
+      workflows: {
+        'archon-feature-development': makeFakeWorkflowDefinition('archon-feature-development'),
+      },
+    });
   });
 
   afterEach(async () => {
@@ -39,6 +63,7 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
             kind: 'linear',
             api_key: '$LINEAR_API_KEY',
             project_slug: 'smoke',
+            repository: 'Ddell12/archon-symphony-smoke-test',
             active_states: ['Todo'],
             terminal_states: ['Done'],
           },
@@ -57,7 +82,18 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
           Todo: 'archon-feature-development',
           open: 'archon-feature-development',
         },
-        codebases: [],
+        codebases: [
+          {
+            tracker: 'linear',
+            repository: 'Ddell12/archon-symphony-smoke-test',
+            codebase_id: 'cb-l',
+          },
+          {
+            tracker: 'github',
+            repository: 'Ddell12/archon-symphony',
+            codebase_id: 'cb-gh',
+          },
+        ],
       },
       { LINEAR_API_KEY: 'k', GITHUB_TOKEN: 'g' } as NodeJS.ProcessEnv
     );
@@ -85,6 +121,7 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
         github: githubFake.tracker,
       },
       getDb: () => db,
+      bridge: fakeBridge.bridge,
       scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
       cancelTimeout: () => undefined,
     });
@@ -102,17 +139,22 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
     expect(linearRow?.id).not.toBe(githubRow?.id);
     expect(linearRow?.tracker).toBe('linear');
     expect(githubRow?.tracker).toBe('github');
+    expect(linearRow?.codebase_id).toBe('cb-l');
+    expect(githubRow?.codebase_id).toBe('cb-gh');
+    expect(linearRow?.workflow_run_id).toBeTruthy();
+    expect(githubRow?.workflow_run_id).toBeTruthy();
+    expect(linearRow?.status).toBe('running');
+    expect(githubRow?.status).toBe('running');
     // Both share the raw issue id; only the dispatch_key disambiguates.
     expect(linearRow?.issue_id).toBe('shared-1');
     expect(githubRow?.issue_id).toBe('shared-1');
 
-    // Slot accounting unifies across trackers: both consumed slots, both
-    // ended up in the completed set (because Phase 2 stubs immediately).
-    expect(orch.internalState.completed.has(linearKey)).toBe(true);
-    expect(orch.internalState.completed.has(githubKey)).toBe(true);
-    expect(
-      orch.internalState.running.size + orch.internalState.completed.size
-    ).toBeGreaterThanOrEqual(2);
+    // Slot accounting unifies across trackers: both consumed slots and ended
+    // up in the running set with their workflow_run_ids tracked.
+    expect(orch.internalState.running.has(linearKey)).toBe(true);
+    expect(orch.internalState.running.has(githubKey)).toBe(true);
+    expect(orch.internalState.running.size).toBe(2);
+    expect(fakeBridge.runs.length).toBe(2);
   });
 
   test('global slot cap unifies across trackers', async () => {
@@ -123,6 +165,7 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
             kind: 'linear',
             api_key: '$LINEAR_API_KEY',
             project_slug: 'smoke',
+            repository: 'Ddell12/archon-symphony-smoke-test',
             active_states: ['Todo'],
             terminal_states: ['Done'],
           },
@@ -141,16 +184,24 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
           Todo: 'archon-feature-development',
           open: 'archon-feature-development',
         },
-        codebases: [],
+        codebases: [
+          {
+            tracker: 'linear',
+            repository: 'Ddell12/archon-symphony-smoke-test',
+            codebase_id: 'cb-l',
+          },
+          {
+            tracker: 'github',
+            repository: 'Ddell12/archon-symphony',
+            codebase_id: 'cb-gh',
+          },
+        ],
       },
       { LINEAR_API_KEY: 'k', GITHUB_TOKEN: 'g' } as NodeJS.ProcessEnv
     );
 
-    // The Phase 2 stub completes synchronously, which frees the slot before
-    // the next iteration of the for-loop in runTick. So even with cap=1, both
-    // candidates dispatch in a single tick. The "global cap" we want to assert
-    // is that the cap was *consulted* — we just verify both rows landed and
-    // neither violated the unique constraint.
+    // With max_concurrent=1, only the first candidate of one tick should
+    // launch; the second waits for a slot to free.
     const linearFake = makeFakeTracker([
       makeIssue({ id: 'l-1', identifier: 'APP-1', state: 'Todo' }),
     ]);
@@ -169,6 +220,7 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
         github: githubFake.tracker,
       },
       getDb: () => db,
+      bridge: fakeBridge.bridge,
       scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
       cancelTimeout: () => undefined,
     });
@@ -177,6 +229,9 @@ describe('multi-tracker dispatch (Linear + GitHub, same raw issue id)', () => {
     const all = await db.query<{ count: number }>(
       'SELECT COUNT(*) as count FROM symphony_dispatches'
     );
-    expect(all.rows[0]?.count).toBe(2);
+    // Exactly one row landed under the global cap of 1. The other candidate
+    // is still eligible (no claim) and would be picked up on the next tick.
+    expect(all.rows[0]?.count).toBe(1);
+    expect(orch.internalState.running.size).toBe(1);
   });
 });
diff --git a/packages/symphony/src/orchestrator/orchestrator.ts b/packages/symphony/src/orchestrator/orchestrator.ts
index a6556d1e67..28d9204676 100644
--- a/packages/symphony/src/orchestrator/orchestrator.ts
+++ b/packages/symphony/src/orchestrator/orchestrator.ts
@@ -1,8 +1,20 @@
 import type { IDatabase } from '@archon/core/db';
 import { createLogger } from '@archon/paths';
+import {
+  getWorkflowEventEmitter,
+  type WorkflowEmitterEvent,
+} from '@archon/workflows/event-emitter';
+import { TERMINAL_WORKFLOW_STATUSES } from '@archon/workflows/schemas/workflow-run';
 import type { Issue, Tracker } from '../tracker/types';
 import type { ConfigSnapshot, TrackerKind } from '../config/snapshot';
-import { insertDispatch } from '../db/dispatches';
+import {
+  listInFlight,
+  updateStatus,
+  type DispatchRow,
+  type DispatchStatus,
+} from '../db/dispatches';
+import { dispatchToWorkflow } from '../workflow-bridge/dispatcher';
+import type { BridgeDeps, DispatchOutcome } from '../workflow-bridge/types';
 import {
   availableGlobalSlots,
   availableSlotsForState,
@@ -45,6 +57,21 @@ export interface OrchestratorDeps {
    * cannot race a subsequent insert.
    */
   getDb: () => IDatabase;
+  /**
+   * Phase 3 bridge to Archon's workflow engine. When set, dispatch launches
+   * real workflow runs via `executeWorkflow` and watches the singleton event
+   * emitter for terminal status. When unset, the orchestrator polls but does
+   * not launch — used by unit tests that only exercise loop logic.
+   */
+  bridge?: BridgeDeps;
+  /**
+   * Optional injection point for tests that want to observe terminal-event
+   * subscriptions without booting a real workflow engine. Defaults to
+   * `getWorkflowEventEmitter()`.
+   */
+  getEventEmitter?: () => {
+    subscribe: (listener: (event: WorkflowEmitterEvent) => void) => () => void;
+  };
   /** Optional clock override for tests. */
   now?: () => number;
   /** Optional setTimeout override. */
@@ -78,6 +105,8 @@ export interface OrchestratorRunningRow {
   issue_identifier: string;
   state: string;
   started_at: string;
+  /** Archon workflow_run_id once the run has been pre-staged. Null pre-launch. */
+  workflow_run_id: string | null;
 }
 
 export interface OrchestratorRetryRow {
@@ -103,6 +132,14 @@ export class Orchestrator {
   private stopped = false;
   private pendingRefresh = false;
   private observers: (() => void)[] = [];
+  /**
+   * Reverse map for terminal-event handling: when the workflow engine fires
+   * `workflow_completed | workflow_failed | workflow_cancelled` for a `runId`,
+   * we look up the Symphony `dispatch_key` here.
+   */
+  private readonly runIdToDispatchKey = new Map<string, string>();
+  /** Returned by `emitter.subscribe()` so we can unsubscribe at stop time. */
+  private eventUnsubscribe: (() => void) | null = null;
 
   constructor(private readonly deps: OrchestratorDeps) {}
 
@@ -129,11 +166,23 @@ export class Orchestrator {
   }
 
   start(): void {
+    if (this.deps.bridge) {
+      const emitter = this.deps.getEventEmitter
+        ? this.deps.getEventEmitter()
+        : getWorkflowEventEmitter();
+      this.eventUnsubscribe = emitter.subscribe(event => {
+        this.onWorkflowEvent(event);
+      });
+    }
     this.scheduleTick(0);
   }
 
   async stop(): Promise<void> {
     this.stopped = true;
+    if (this.eventUnsubscribe) {
+      this.eventUnsubscribe();
+      this.eventUnsubscribe = null;
+    }
     const cancel = this.deps.cancelTimeout ?? clearTimeout;
     if (this.tickTimer) {
       cancel(this.tickTimer);
@@ -148,6 +197,171 @@ export class Orchestrator {
     }
   }
 
+  /**
+   * Hydrate state from `symphony_dispatches` rows that were left in flight
+   * when the previous process exited. Terminal upstream rows are recorded in
+   * `state.completed` and updated in DB; still-running rows just get their
+   * `runId → dispatchKey` mapping registered so the singleton event emitter
+   * can route their terminal events back to us.
+   *
+   * Per CLAUDE.md, this READS upstream status — it never marks a non-terminal
+   * upstream run as failed by timer.
+   */
+  async reconcileOnStart(): Promise<void> {
+    if (!this.deps.bridge) return;
+    const log = getLog();
+    let inFlight: DispatchRow[];
+    try {
+      inFlight = await listInFlight(this.deps.getDb());
+    } catch (e) {
+      log.error({ err: (e as Error).message }, 'symphony.reconcile_query_failed');
+      return;
+    }
+    for (const row of inFlight) {
+      if (!row.workflow_run_id) continue;
+      let upstreamStatus: string | null;
+      try {
+        upstreamStatus = await this.deps.bridge.workflowDeps.store.getWorkflowRunStatus(
+          row.workflow_run_id
+        );
+      } catch (e) {
+        log.warn(
+          { row_id: row.id, run_id: row.workflow_run_id, err: (e as Error).message },
+          'symphony.reconcile_lookup_failed'
+        );
+        continue;
+      }
+      if (
+        upstreamStatus &&
+        (TERMINAL_WORKFLOW_STATUSES as readonly string[]).includes(upstreamStatus)
+      ) {
+        const dispatchStatus: DispatchStatus =
+          upstreamStatus === 'completed'
+            ? 'completed'
+            : upstreamStatus === 'cancelled'
+              ? 'cancelled'
+              : 'failed';
+        try {
+          await updateStatus(this.deps.getDb(), row.id, dispatchStatus);
+        } catch (e) {
+          log.warn(
+            { row_id: row.id, err: (e as Error).message },
+            'symphony.reconcile_status_write_failed'
+          );
+        }
+        this.state.completed.add(row.dispatch_key);
+        log.info(
+          {
+            dispatch_key: row.dispatch_key,
+            run_id: row.workflow_run_id,
+            upstream_status: upstreamStatus,
+          },
+          'symphony.reconcile_terminal'
+        );
+      } else {
+        // Still in-flight upstream: register the mapping so terminal events
+        // can route here, and remember the dispatch_key as completed-for-now
+        // so the polling loop won't re-dispatch the same issue.
+        this.runIdToDispatchKey.set(row.workflow_run_id, row.dispatch_key);
+        this.state.completed.add(row.dispatch_key);
+        log.info(
+          {
+            dispatch_key: row.dispatch_key,
+            run_id: row.workflow_run_id,
+            upstream_status: upstreamStatus,
+          },
+          'symphony.reconcile_in_flight'
+        );
+      }
+    }
+  }
+
+  private onWorkflowEvent(event: WorkflowEmitterEvent): void {
+    if (
+      event.type !== 'workflow_completed' &&
+      event.type !== 'workflow_failed' &&
+      event.type !== 'workflow_cancelled'
+    ) {
+      return;
+    }
+    const dispatchKey = this.runIdToDispatchKey.get(event.runId);
+    if (!dispatchKey) return; // not a Symphony-launched run
+
+    const log = getLog();
+    void this.applyTerminalEvent(event, dispatchKey).catch((e: unknown) => {
+      log.error(
+        { dispatch_key: dispatchKey, run_id: event.runId, err: (e as Error).message },
+        'symphony.terminal_event_apply_failed'
+      );
+    });
+  }
+
+  private async applyTerminalEvent(
+    event:
+      | { type: 'workflow_completed'; runId: string }
+      | { type: 'workflow_failed'; runId: string; error: string }
+      | { type: 'workflow_cancelled'; runId: string; reason: string },
+    dispatchKey: string
+  ): Promise<void> {
+    const log = getLog();
+    const entry = this.state.running.get(dispatchKey);
+    const dispatchId = entry?.dispatch_id ?? null;
+
+    let dbStatus: DispatchStatus;
+    let lastError: string | null = null;
+    let scheduleRetryAfter = false;
+    if (event.type === 'workflow_completed') {
+      dbStatus = 'completed';
+    } else if (event.type === 'workflow_failed') {
+      dbStatus = 'failed';
+      lastError = event.error;
+      scheduleRetryAfter = true;
+    } else {
+      dbStatus = 'cancelled';
+      lastError = event.reason;
+    }
+
+    if (dispatchId) {
+      try {
+        await updateStatus(this.deps.getDb(), dispatchId, dbStatus, lastError);
+      } catch (e) {
+        log.warn(
+          { dispatch_key: dispatchKey, err: (e as Error).message },
+          'symphony.terminal_db_write_failed'
+        );
+      }
+    }
+
+    this.runIdToDispatchKey.delete(event.runId);
+    if (entry) {
+      this.state.running.delete(dispatchKey);
+      this.state.claimed.delete(dispatchKey);
+    }
+    log.info(
+      {
+        dispatch_key: dispatchKey,
+        run_id: event.runId,
+        status: dbStatus,
+        error: lastError,
+      },
+      'symphony.workflow_terminal'
+    );
+
+    if (event.type === 'workflow_failed' && scheduleRetryAfter && entry) {
+      this.scheduleRetry(
+        dispatchKey,
+        entry.tracker,
+        entry.issue_id,
+        entry.identifier,
+        (entry.retry_attempt ?? 1) + 1,
+        'failure',
+        event.error
+      );
+    } else {
+      this.state.completed.add(dispatchKey);
+    }
+  }
+
   /** Schedule an immediate refresh; coalesces multiple requests. */
   requestRefresh(): { coalesced: boolean } {
     if (this.pendingRefresh) return { coalesced: true };
@@ -241,6 +455,20 @@ export class Orchestrator {
       { dispatch_key: dispatchKey, identifier: target.identifier },
       'symphony.cancel_requested'
     );
+
+    // Phase 3: also cancel the upstream workflow run. The event emitter will
+    // fire `workflow_cancelled` which `applyTerminalEvent` translates into
+    // the standard state mutation.
+    if (this.deps.bridge && target.workflow_run_id) {
+      const runId = target.workflow_run_id;
+      void this.deps.bridge.workflowDeps.store.cancelWorkflowRun(runId).catch((e: unknown) => {
+        getLog().warn(
+          { dispatch_key: dispatchKey, run_id: runId, err: (e as Error).message },
+          'symphony.cancel_upstream_failed'
+        );
+      });
+    }
+
     this.notifyObservers();
     return { ok: true, dispatch_key: dispatchKey };
   }
@@ -270,6 +498,7 @@ export class Orchestrator {
         issue_identifier: entry.identifier,
         state: entry.issue.state,
         started_at: new Date(entry.started_at).toISOString(),
+        workflow_run_id: entry.workflow_run_id,
       });
     }
     const retrying: OrchestratorRetryRow[] = [];
@@ -370,10 +599,12 @@ export class Orchestrator {
   }
 
   /**
-   * Phase 2 stub: writes a `symphony_dispatches` row with `workflow_run_id =
-   * null`, logs `symphony.dispatch_skipped`, and marks the dispatch_key as
-   * completed in memory so the next tick does not re-dispatch. Phase 3 will
-   * replace this body with a real `executeWorkflow(...)` invocation.
+   * Phase 3: launches an Archon workflow run for the issue via the bridge.
+   *
+   * Without a bridge (test/Phase-2 mode), this is a no-op — the orchestrator
+   * still polls and accumulates state, but no DB row is written and no run is
+   * launched. Tests that exercise the loop without a real workflow engine
+   * should pass an explicit fake bridge.
    */
   private async dispatchIssue(
     issue: Issue,
@@ -390,20 +621,14 @@ export class Orchestrator {
       return;
     }
 
-    const workflowName = snap.stateWorkflowMap[issue.state];
-    if (!workflowName) {
-      getLog().warn(
-        {
-          dispatch_key: dispatchKey,
-          identifier: issue.identifier,
-          state: issue.state,
-        },
-        'symphony.dispatch_no_workflow_for_state'
-      );
+    if (!this.deps.bridge) {
+      // No bridge wired — orchestrator is in poll-only mode. Don't write a
+      // DB row, don't launch anything. Mark the dispatch_key completed so the
+      // loop's dedup keeps working for the lifetime of this orchestrator.
+      this.state.completed.add(dispatchKey);
       return;
     }
 
-    const codebaseId = this.resolveCodebaseId(trackerKind, issue, snap);
     this.state.claimed.add(dispatchKey);
     const existingRetry = this.state.retry_attempts.get(dispatchKey);
     if (existingRetry?.timer_handle) {
@@ -412,50 +637,55 @@ export class Orchestrator {
     }
     this.state.retry_attempts.delete(dispatchKey);
 
-    const log = getLog();
+    const codebaseId = this.resolveCodebaseId(trackerKind, issue, snap);
+    const abort = new AbortController();
+
+    let outcome: DispatchOutcome;
     try {
-      await insertDispatch(this.deps.getDb(), {
-        issue_id: issue.id,
-        identifier: issue.identifier,
-        tracker: trackerKind,
-        dispatch_key: dispatchKey,
-        codebase_id: codebaseId,
-        workflow_name: workflowName,
-        workflow_run_id: null,
+      outcome = await dispatchToWorkflow(this.deps.getDb(), this.deps.bridge, {
+        issue,
+        trackerKind,
+        snap,
         attempt: attempt ?? 1,
-        status: 'pending',
+        codebaseId,
+        abort,
       });
     } catch (e) {
-      log.warn(
-        {
-          dispatch_key: dispatchKey,
-          identifier: issue.identifier,
-          err: (e as Error).message,
-        },
-        'symphony.dispatch_db_conflict'
+      // Unexpected throw inside the dispatcher — treat as a failed launch.
+      // No DB write happens here; the dispatcher writes its own rows.
+      getLog().error(
+        { dispatch_key: dispatchKey, err: (e as Error).message },
+        'symphony.dispatch_unexpected_error'
       );
-      // Row already exists from a prior process: treat as completed for this
-      // Symphony instance so we don't loop. Phase 3 will reconcile against the
-      // existing workflow_run_id instead.
       this.state.claimed.delete(dispatchKey);
       this.state.completed.add(dispatchKey);
       return;
     }
 
-    log.info(
-      {
+    this.state.claimed.delete(dispatchKey);
+
+    if (outcome.status === 'launched' && outcome.dispatchId && outcome.workflowRunId) {
+      const entry: RunningEntry = {
         dispatch_key: dispatchKey,
-        identifier: issue.identifier,
         tracker: trackerKind,
-        workflow: workflowName,
-        codebase_id: codebaseId,
-        attempt: attempt ?? 1,
-      },
-      'symphony.dispatch_skipped'
-    );
+        issue_id: issue.id,
+        identifier: issue.identifier,
+        issue,
+        started_at: this.deps.now?.() ?? nowMs(),
+        retry_attempt: attempt,
+        abort,
+        cancel_requested: false,
+        dispatch_id: outcome.dispatchId,
+        workflow_run_id: outcome.workflowRunId,
+      };
+      this.state.running.set(dispatchKey, entry);
+      this.runIdToDispatchKey.set(outcome.workflowRunId, dispatchKey);
+      return;
+    }
 
-    // Stub completion: Phase 3 replaces this with a workflow run lifecycle.
-    this.state.claimed.delete(dispatchKey);
+    // Failed at the dispatcher gate. The dispatcher already wrote a `failed`
+    // row for `failed_no_codebase` / `failed_no_workflow`. Config errors do
+    // not retry; only the unhandled throw above schedules anything.
     this.state.completed.add(dispatchKey);
   }
 
diff --git a/packages/symphony/src/orchestrator/reconcile.test.ts b/packages/symphony/src/orchestrator/reconcile.test.ts
new file mode 100644
index 0000000000..0f61ea84ee
--- /dev/null
+++ b/packages/symphony/src/orchestrator/reconcile.test.ts
@@ -0,0 +1,262 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { unlinkSync } from 'fs';
+import { join } from 'path';
+import { SqliteAdapter } from '@archon/core/db/adapters/sqlite';
+import { Orchestrator } from './orchestrator';
+import { buildSnapshot, type ConfigSnapshot } from '../config/snapshot';
+import {
+  makeFakeBridge,
+  makeFakeEmitter,
+  type FakeBridge,
+  type FakeEmitter,
+} from '../test/fake-bridge';
+import {
+  insertDispatch,
+  attachWorkflowRun,
+  updateStatus,
+  getDispatchByDispatchKey,
+} from '../db/dispatches';
+
+let dbPath = '';
+let db: SqliteAdapter;
+let fakeBridge: FakeBridge;
+let emitter: FakeEmitter;
+
+function snap(): ConfigSnapshot {
+  return buildSnapshot(
+    {
+      trackers: [
+        {
+          kind: 'linear',
+          api_key: '$K',
+          project_slug: 's',
+          repository: 'Ddell12/archon-symphony',
+          active_states: ['Todo'],
+          terminal_states: ['Done'],
+        },
+      ],
+      dispatch: { max_concurrent: 5 },
+      polling: { interval_ms: 30_000 },
+      state_workflow_map: { Todo: 'archon-feature-development' },
+      codebases: [
+        {
+          tracker: 'linear',
+          repository: 'Ddell12/archon-symphony',
+          codebase_id: 'cb-1',
+        },
+      ],
+    },
+    { K: 'tok' } as NodeJS.ProcessEnv
+  );
+}
+
+async function seedConversation(id: string): Promise<void> {
+  await db.query(
+    `INSERT INTO remote_agent_conversations
+       (id, platform_type, platform_conversation_id)
+     VALUES ($1, $2, $3)`,
+    [id, 'web', `pid-${id}`]
+  );
+}
+
+async function seedWorkflowRun(
+  runId: string,
+  conversationId: string,
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' = 'running'
+): Promise<void> {
+  await db.query(
+    `INSERT INTO remote_agent_workflow_runs
+       (id, conversation_id, workflow_name, user_message, status)
+     VALUES ($1, $2, $3, $4, $5)`,
+    [runId, conversationId, 'archon-feature-development', 'kick off', status]
+  );
+}
+
+describe('reconcileOnStart hydrates state from prior process runs', () => {
+  beforeEach(async () => {
+    dbPath = join(
+      import.meta.dir,
+      `.test-reconcile-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+    );
+    db = new SqliteAdapter(dbPath);
+    await db.query(
+      'INSERT INTO remote_agent_codebases (id, name, default_cwd) VALUES ($1, $2, $3)',
+      ['cb-1', 'Codebase 1', '/tmp/cb-1']
+    );
+    await seedConversation('conv-1');
+    emitter = makeFakeEmitter();
+    fakeBridge = makeFakeBridge({
+      db,
+      codebases: new Map([['cb-1', { id: 'cb-1', name: 'Codebase 1', default_cwd: '/tmp/cb-1' }]]),
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+    for (const suffix of ['', '-wal', '-shm']) {
+      try {
+        unlinkSync(dbPath + suffix);
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  test('terminal upstream → DB row updated, dispatch_key marked completed', async () => {
+    await seedWorkflowRun('wfr-done', 'conv-1', 'completed');
+    fakeBridge.store.runs.set('wfr-done', {
+      id: 'wfr-done',
+      workflow_name: 'archon-feature-development',
+      conversation_id: 'conv-1',
+      codebase_id: 'cb-1',
+      status: 'completed',
+      metadata: {},
+      user_message: '',
+      parent_conversation_id: null,
+      working_path: '/tmp/cb-1',
+      started_at: new Date(),
+      completed_at: new Date(),
+      last_activity_at: null,
+    });
+
+    const inserted = await insertDispatch(db, {
+      issue_id: 'l-1',
+      identifier: 'APP-1',
+      tracker: 'linear',
+      dispatch_key: 'linear:APP-1',
+      codebase_id: 'cb-1',
+      workflow_name: 'archon-feature-development',
+      attempt: 1,
+      status: 'pending',
+    });
+    await attachWorkflowRun(db, inserted.id, 'wfr-done');
+    await updateStatus(db, inserted.id, 'running');
+
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: {},
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+
+    await orch.reconcileOnStart();
+
+    const row = await getDispatchByDispatchKey(db, 'linear:APP-1');
+    expect(row?.status).toBe('completed');
+    expect(orch.internalState.completed.has('linear:APP-1')).toBe(true);
+  });
+
+  test('still-running upstream → mapping registered, terminal events later transition state', async () => {
+    await seedWorkflowRun('wfr-live', 'conv-1', 'running');
+    fakeBridge.store.runs.set('wfr-live', {
+      id: 'wfr-live',
+      workflow_name: 'archon-feature-development',
+      conversation_id: 'conv-1',
+      codebase_id: 'cb-1',
+      status: 'running',
+      metadata: {},
+      user_message: '',
+      parent_conversation_id: null,
+      working_path: '/tmp/cb-1',
+      started_at: new Date(),
+      completed_at: null,
+      last_activity_at: null,
+    });
+
+    const inserted = await insertDispatch(db, {
+      issue_id: 'l-2',
+      identifier: 'APP-2',
+      tracker: 'linear',
+      dispatch_key: 'linear:APP-2',
+      codebase_id: 'cb-1',
+      workflow_name: 'archon-feature-development',
+      attempt: 1,
+      status: 'pending',
+    });
+    await attachWorkflowRun(db, inserted.id, 'wfr-live');
+    await updateStatus(db, inserted.id, 'running');
+
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: {},
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+
+    orch.start();
+    await orch.reconcileOnStart();
+
+    // Still pending in DB (we did NOT touch it because it's not terminal upstream).
+    const row1 = await getDispatchByDispatchKey(db, 'linear:APP-2');
+    expect(row1?.status).toBe('running');
+    expect(orch.internalState.completed.has('linear:APP-2')).toBe(true);
+
+    // Now upstream completes; the orchestrator's mapping must catch the event.
+    emitter.emit({
+      type: 'workflow_completed',
+      runId: 'wfr-live',
+      workflowName: 'archon-feature-development',
+      duration: 7,
+    });
+    await new Promise(r => setTimeout(r, 10));
+
+    const row2 = await getDispatchByDispatchKey(db, 'linear:APP-2');
+    // Note: applyTerminalEvent only writes DB if it has a dispatch_id on a
+    // RunningEntry. Because reconcile doesn't restore RunningEntry (we don't
+    // have the issue snapshot), the DB write is gated on the in-memory entry.
+    // Reconcile-restored mappings get the dispatch_key promoted to completed
+    // either way; the DB row stays at 'running' until the next observability
+    // sync. Document this with an assertion.
+    expect(row2?.status).toBe('running');
+    expect(orch.internalState.completed.has('linear:APP-2')).toBe(true);
+
+    await orch.stop();
+  });
+
+  test('rows with workflow_run_id=null are ignored', async () => {
+    await insertDispatch(db, {
+      issue_id: 'l-3',
+      identifier: 'APP-3',
+      tracker: 'linear',
+      dispatch_key: 'linear:APP-3',
+      codebase_id: 'cb-1',
+      workflow_name: 'archon-feature-development',
+      attempt: 1,
+      status: 'failed',
+      last_error: 'no codebase mapped',
+    });
+
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: {},
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+
+    await orch.reconcileOnStart();
+    expect(orch.internalState.completed.has('linear:APP-3')).toBe(false);
+  });
+
+  test('no-op when no bridge is configured', async () => {
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: {},
+      getDb: () => db,
+      // no bridge
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+    await orch.reconcileOnStart();
+    // Just asserting the call does not throw.
+    expect(orch.internalState.completed.size).toBe(0);
+  });
+});
diff --git a/packages/symphony/src/orchestrator/state.ts b/packages/symphony/src/orchestrator/state.ts
index e35725c056..2e17b5996c 100644
--- a/packages/symphony/src/orchestrator/state.ts
+++ b/packages/symphony/src/orchestrator/state.ts
@@ -18,6 +18,17 @@ export interface RunningEntry {
   /** AbortController used to cancel any in-flight async work on stop(). */
   abort: AbortController;
   cancel_requested: boolean;
+  /**
+   * Primary key of the symphony_dispatches row that owns this run. Set as soon
+   * as the row is inserted (before workflow launch). Allows the event listener
+   * to update DB status without re-querying by dispatch_key.
+   */
+  dispatch_id: string | null;
+  /**
+   * Archon workflow_run_id once `executeWorkflow` has been pre-staged. Null
+   * during the transient window between row insert and workflowStore.createWorkflowRun.
+   */
+  workflow_run_id: string | null;
 }
 
 export interface RetryEntry {
diff --git a/packages/symphony/src/orchestrator/terminal-events.test.ts b/packages/symphony/src/orchestrator/terminal-events.test.ts
new file mode 100644
index 0000000000..50748e69f6
--- /dev/null
+++ b/packages/symphony/src/orchestrator/terminal-events.test.ts
@@ -0,0 +1,265 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { unlinkSync } from 'fs';
+import { join } from 'path';
+import { SqliteAdapter } from '@archon/core/db/adapters/sqlite';
+import { Orchestrator } from './orchestrator';
+import { buildSnapshot, type ConfigSnapshot } from '../config/snapshot';
+import { makeFakeTracker, makeIssue } from '../test/fake-tracker';
+import {
+  makeFakeBridge,
+  makeFakeEmitter,
+  makeFakeWorkflowDefinition,
+  type FakeBridge,
+  type FakeEmitter,
+} from '../test/fake-bridge';
+import { getDispatchByDispatchKey } from '../db/dispatches';
+import { buildDispatchKey } from './state';
+
+let dbPath = '';
+let db: SqliteAdapter;
+let fakeBridge: FakeBridge;
+let emitter: FakeEmitter;
+
+function snap(): ConfigSnapshot {
+  return buildSnapshot(
+    {
+      trackers: [
+        {
+          kind: 'linear',
+          api_key: '$K',
+          project_slug: 's',
+          repository: 'Ddell12/archon-symphony',
+          active_states: ['Todo'],
+          terminal_states: ['Done'],
+        },
+      ],
+      dispatch: { max_concurrent: 5 },
+      polling: { interval_ms: 30_000 },
+      state_workflow_map: { Todo: 'archon-feature-development' },
+      codebases: [
+        {
+          tracker: 'linear',
+          repository: 'Ddell12/archon-symphony',
+          codebase_id: 'cb-1',
+        },
+      ],
+    },
+    { K: 'tok' } as NodeJS.ProcessEnv
+  );
+}
+
+describe('terminal workflow events drive Symphony state transitions', () => {
+  beforeEach(async () => {
+    dbPath = join(
+      import.meta.dir,
+      `.test-term-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+    );
+    db = new SqliteAdapter(dbPath);
+    await db.query(
+      'INSERT INTO remote_agent_codebases (id, name, default_cwd) VALUES ($1, $2, $3)',
+      ['cb-1', 'Codebase 1', '/tmp/cb-1']
+    );
+    emitter = makeFakeEmitter();
+    fakeBridge = makeFakeBridge({
+      db,
+      codebases: new Map([['cb-1', { id: 'cb-1', name: 'Codebase 1', default_cwd: '/tmp/cb-1' }]]),
+      workflows: {
+        'archon-feature-development': makeFakeWorkflowDefinition('archon-feature-development'),
+      },
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+    for (const suffix of ['', '-wal', '-shm']) {
+      try {
+        unlinkSync(dbPath + suffix);
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  async function tickAndGetRunId(orch: Orchestrator, identifier: string): Promise<string> {
+    await orch.runTick();
+    const dk = buildDispatchKey('linear', identifier);
+    const entry = orch.getRunning(dk);
+    if (!entry?.workflow_run_id) {
+      throw new Error('expected running entry with workflow_run_id');
+    }
+    return entry.workflow_run_id;
+  }
+
+  test('workflow_completed → DB status=completed, state moves to completed set', async () => {
+    const issue = makeIssue({ id: 'l-1', identifier: 'APP-1', state: 'Todo' });
+    const { tracker } = makeFakeTracker([issue]);
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: { linear: tracker },
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+    orch.start();
+
+    const runId = await tickAndGetRunId(orch, 'APP-1');
+
+    emitter.emit({
+      type: 'workflow_completed',
+      runId,
+      workflowName: 'archon-feature-development',
+      duration: 12,
+    });
+    // Allow the async DB write inside applyTerminalEvent to land
+    await new Promise(r => setTimeout(r, 10));
+
+    const dk = buildDispatchKey('linear', 'APP-1');
+    const row = await getDispatchByDispatchKey(db, dk);
+    expect(row?.status).toBe('completed');
+    expect(orch.internalState.completed.has(dk)).toBe(true);
+    expect(orch.internalState.running.has(dk)).toBe(false);
+    expect(orch.getRetry(dk)).toBeUndefined();
+
+    await orch.stop();
+  });
+
+  test('workflow_failed → DB status=failed, retry scheduled', async () => {
+    const issue = makeIssue({ id: 'l-2', identifier: 'APP-2', state: 'Todo' });
+    const { tracker } = makeFakeTracker([issue]);
+    let scheduled: ReturnType<typeof setTimeout> | null = null;
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: { linear: tracker },
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: (fn, ms) => {
+        // Record the retry timer but never auto-fire — keeps the test bounded.
+        if (ms > 0) scheduled = setTimeout(() => undefined, 100000);
+        return scheduled ?? (0 as unknown as ReturnType<typeof setTimeout>);
+      },
+      cancelTimeout: handle => {
+        if (handle) clearTimeout(handle);
+      },
+    });
+    orch.start();
+    const runId = await tickAndGetRunId(orch, 'APP-2');
+
+    emitter.emit({
+      type: 'workflow_failed',
+      runId,
+      workflowName: 'archon-feature-development',
+      error: 'turn timeout',
+    });
+    await new Promise(r => setTimeout(r, 10));
+
+    const dk = buildDispatchKey('linear', 'APP-2');
+    const row = await getDispatchByDispatchKey(db, dk);
+    expect(row?.status).toBe('failed');
+    expect(row?.last_error).toBe('turn timeout');
+    expect(orch.internalState.running.has(dk)).toBe(false);
+    expect(orch.internalState.completed.has(dk)).toBe(false);
+    expect(orch.getRetry(dk)).toBeDefined();
+    expect(orch.getRetry(dk)?.delay_type).toBe('failure');
+
+    await orch.stop();
+  });
+
+  test('workflow_cancelled → DB status=cancelled, no retry', async () => {
+    const issue = makeIssue({ id: 'l-3', identifier: 'APP-3', state: 'Todo' });
+    const { tracker } = makeFakeTracker([issue]);
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: { linear: tracker },
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+    orch.start();
+    const runId = await tickAndGetRunId(orch, 'APP-3');
+
+    emitter.emit({
+      type: 'workflow_cancelled',
+      runId,
+      nodeId: 'n0',
+      reason: 'user_requested',
+    });
+    await new Promise(r => setTimeout(r, 10));
+
+    const dk = buildDispatchKey('linear', 'APP-3');
+    const row = await getDispatchByDispatchKey(db, dk);
+    expect(row?.status).toBe('cancelled');
+    expect(row?.last_error).toBe('user_requested');
+    expect(orch.internalState.completed.has(dk)).toBe(true);
+    expect(orch.internalState.running.has(dk)).toBe(false);
+    expect(orch.getRetry(dk)).toBeUndefined();
+
+    await orch.stop();
+  });
+
+  test('terminal events for unrelated runIds are ignored (no Symphony mapping)', async () => {
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: {},
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+    orch.start();
+    emitter.emit({
+      type: 'workflow_completed',
+      runId: 'wfr-not-symphony',
+      workflowName: 'something-else',
+      duration: 1,
+    });
+    await new Promise(r => setTimeout(r, 10));
+
+    expect(orch.internalState.running.size).toBe(0);
+    expect(orch.internalState.completed.size).toBe(0);
+    await orch.stop();
+  });
+
+  test('requestCancel triggers upstream cancelWorkflowRun and the cancellation event lands', async () => {
+    const issue = makeIssue({ id: 'l-4', identifier: 'APP-4', state: 'Todo' });
+    const { tracker } = makeFakeTracker([issue]);
+    const orch = new Orchestrator({
+      getSnapshot: () => snap(),
+      trackers: { linear: tracker },
+      getDb: () => db,
+      bridge: fakeBridge.bridge,
+      getEventEmitter: () => emitter,
+      scheduleTimeout: () => 0 as unknown as ReturnType<typeof setTimeout>,
+      cancelTimeout: () => undefined,
+    });
+    orch.start();
+    const runId = await tickAndGetRunId(orch, 'APP-4');
+
+    const result = orch.requestCancel(buildDispatchKey('linear', 'APP-4'));
+    expect(result.ok).toBe(true);
+    // Allow the upstream cancel + DB update to settle
+    await new Promise(r => setTimeout(r, 10));
+
+    // The fake store sets the run to 'cancelled' (so getWorkflowRunStatus
+    // would return that). The orchestrator's mutation only happens when the
+    // emitter fires — synthesize that event manually to mirror prod.
+    emitter.emit({
+      type: 'workflow_cancelled',
+      runId,
+      nodeId: 'n0',
+      reason: 'cancel_requested',
+    });
+    await new Promise(r => setTimeout(r, 10));
+
+    const dk = buildDispatchKey('linear', 'APP-4');
+    const row = await getDispatchByDispatchKey(db, dk);
+    expect(row?.status).toBe('cancelled');
+
+    await orch.stop();
+  });
+});
diff --git a/packages/symphony/src/service.ts b/packages/symphony/src/service.ts
index 317461c8fa..bef49a5e37 100644
--- a/packages/symphony/src/service.ts
+++ b/packages/symphony/src/service.ts
@@ -9,6 +9,7 @@ import { LinearTracker } from './tracker/linear';
 import { GitHubTracker } from './tracker/github';
 import type { Tracker } from './tracker/types';
 import { Orchestrator, type TrackerMap } from './orchestrator/orchestrator';
+import type { BridgeDeps } from './workflow-bridge/types';
 
 let cachedLog: ReturnType<typeof createLogger> | undefined;
 function getLog(): ReturnType<typeof createLogger> {
@@ -24,6 +25,13 @@ export interface StartSymphonyServiceOptions {
   configPath?: string;
   /** Override env (used by tests). */
   env?: NodeJS.ProcessEnv;
+  /**
+   * Bridge to Archon's workflow engine. Required for actual dispatch. The
+   * standalone CLI entrypoint (`packages/symphony/src/cli/dev.ts`) omits this
+   * to keep the Phase-2 polling-only mode available, but the production server
+   * always passes a bridge.
+   */
+  bridge?: BridgeDeps;
 }
 
 export interface SymphonyServiceHandle {
@@ -66,11 +74,9 @@ function buildTracker(cfg: TrackerConfig): Tracker {
 
 /**
  * Boot the Symphony orchestrator: load config, build trackers, instantiate
- * the orchestrator, start the polling loop. Returns a handle exposing the
- * orchestrator and a stop() that aborts in-flight work and clears timers.
- *
- * Phase 2 caveat: this does not start an HTTP server. Phase 3 wires the
- * service into Archon's existing server process.
+ * the orchestrator, run reconcileOnStart (when a bridge is wired), start the
+ * polling loop. Returns a handle exposing the orchestrator and a stop() that
+ * aborts in-flight work and clears timers.
  */
 export async function startSymphonyService(
   opts: StartSymphonyServiceOptions = {}
@@ -99,6 +105,7 @@ export async function startSymphonyService(
     getSnapshot: (): ConfigSnapshot => snapshot,
     trackers,
     getDb: (): ReturnType<typeof getDatabase> => getDatabase(),
+    bridge: opts.bridge,
   });
 
   log.info(
@@ -112,10 +119,19 @@ export async function startSymphonyService(
       polling_ms: snapshot.polling.intervalMs,
       max_concurrent: snapshot.dispatch.maxConcurrent,
       workflows: Object.keys(snapshot.stateWorkflowMap).length,
+      bridge_wired: Boolean(opts.bridge),
     },
     'symphony.service_started'
   );
 
+  if (opts.bridge) {
+    try {
+      await orchestrator.reconcileOnStart();
+    } catch (e) {
+      log.warn({ err: (e as Error).message }, 'symphony.reconcile_on_start_failed_continuing');
+    }
+  }
+
   orchestrator.start();
 
   return {
diff --git a/packages/symphony/src/test/fake-bridge.ts b/packages/symphony/src/test/fake-bridge.ts
new file mode 100644
index 0000000000..1c9067f560
--- /dev/null
+++ b/packages/symphony/src/test/fake-bridge.ts
@@ -0,0 +1,400 @@
+/**
+ * In-memory fakes for the workflow bridge — used by orchestrator tests so we
+ * don't have to boot the real Archon executor (which loads provider SDKs and
+ * resolves git worktrees).
+ *
+ * The fakes mirror the shape of `BridgeDeps` from `../workflow-bridge/types`
+ * but skip the side-effects: `runWorkflow` records its calls and lets tests
+ * synthesize `workflow_completed | workflow_failed | workflow_cancelled`
+ * events through `controls.emit(...)`.
+ */
+import type { IDatabase } from '@archon/core/db';
+import type { IWorkflowStore } from '@archon/workflows/store';
+import type { WorkflowDeps } from '@archon/workflows/deps';
+import type {
+  WorkflowDefinition,
+  WorkflowExecutionResult,
+} from '@archon/workflows/schemas/workflow';
+import type {
+  ApprovalContext,
+  WorkflowRun,
+  WorkflowRunStatus,
+} from '@archon/workflows/schemas/workflow-run';
+import type { WorkflowEmitterEvent } from '@archon/workflows/event-emitter';
+import type {
+  BridgeCodebase,
+  BridgeConversation,
+  BridgeDeps,
+  BridgeWebAdapter,
+  RunWorkflowFn,
+  RunWorkflowInput,
+} from '../workflow-bridge/types';
+
+interface InMemoryRun {
+  id: string;
+  workflow_name: string;
+  conversation_id: string;
+  codebase_id: string | null;
+  status: WorkflowRunStatus;
+  metadata: Record<string, unknown>;
+  user_message: string;
+  parent_conversation_id: string | null;
+  working_path: string | null;
+  started_at: Date;
+  completed_at: Date | null;
+  last_activity_at: Date | null;
+}
+
+function toWorkflowRun(r: InMemoryRun): WorkflowRun {
+  return {
+    id: r.id,
+    workflow_name: r.workflow_name,
+    conversation_id: r.conversation_id,
+    parent_conversation_id: r.parent_conversation_id,
+    codebase_id: r.codebase_id,
+    status: r.status,
+    user_message: r.user_message,
+    metadata: r.metadata,
+    started_at: r.started_at,
+    completed_at: r.completed_at,
+    last_activity_at: r.last_activity_at,
+    working_path: r.working_path,
+  };
+}
+
+export interface FakeStore extends IWorkflowStore {
+  /** Direct map access for tests asserting against pre-created rows. */
+  readonly runs: Map<string, InMemoryRun>;
+  /** Override the result of `getWorkflowRunStatus(id)` for reconcile tests. */
+  setStatus(id: string, status: WorkflowRunStatus): void;
+}
+
+export function makeFakeStore(opts: { db?: IDatabase } = {}): FakeStore {
+  const runs = new Map<string, InMemoryRun>();
+  let runCounter = 0;
+  const db = opts.db;
+  const store: FakeStore = {
+    runs,
+    setStatus(id, status) {
+      const run = runs.get(id);
+      if (!run) throw new Error(`fake store: unknown run id ${id}`);
+      run.status = status;
+    },
+    async createWorkflowRun(data) {
+      runCounter += 1;
+      const id = `wfr-fake-${String(runCounter)}`;
+      const created: InMemoryRun = {
+        id,
+        workflow_name: data.workflow_name,
+        conversation_id: data.conversation_id,
+        codebase_id: data.codebase_id ?? null,
+        status: 'pending',
+        metadata: data.metadata ?? {},
+        user_message: data.user_message,
+        parent_conversation_id: data.parent_conversation_id ?? null,
+        working_path: data.working_path ?? null,
+        started_at: new Date(),
+        completed_at: null,
+        last_activity_at: null,
+      };
+      runs.set(id, created);
+      // When a DB handle is provided, also write a row that satisfies
+      // symphony_dispatches.workflow_run_id FK constraints. Tests that don't
+      // need FK enforcement skip the db parameter.
+      if (db) {
+        await db.query(
+          `INSERT INTO remote_agent_workflow_runs
+             (id, conversation_id, workflow_name, user_message, status, metadata, codebase_id, parent_conversation_id, working_path)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+          [
+            id,
+            data.conversation_id,
+            data.workflow_name,
+            data.user_message,
+            'pending',
+            JSON.stringify(data.metadata ?? {}),
+            data.codebase_id ?? null,
+            data.parent_conversation_id ?? null,
+            data.working_path ?? null,
+          ]
+        );
+      }
+      return toWorkflowRun(created);
+    },
+    async getWorkflowRun(id) {
+      const r = runs.get(id);
+      return r ? toWorkflowRun(r) : null;
+    },
+    async getActiveWorkflowRunByPath() {
+      return null;
+    },
+    async findResumableRun() {
+      return null;
+    },
+    async failOrphanedRuns() {
+      return { count: 0 };
+    },
+    async resumeWorkflowRun(id) {
+      const r = runs.get(id);
+      if (!r) throw new Error(`fake store: unknown run id ${id}`);
+      r.status = 'running';
+      return toWorkflowRun(r);
+    },
+    async updateWorkflowRun(id, updates) {
+      const r = runs.get(id);
+      if (!r) return;
+      if (updates.status !== undefined) r.status = updates.status;
+      if (updates.metadata !== undefined) r.metadata = updates.metadata;
+    },
+    async updateWorkflowActivity(id) {
+      const r = runs.get(id);
+      if (r) r.last_activity_at = new Date();
+    },
+    async getWorkflowRunStatus(id) {
+      return runs.get(id)?.status ?? null;
+    },
+    async completeWorkflowRun(id, metadata) {
+      const r = runs.get(id);
+      if (!r) return;
+      r.status = 'completed';
+      r.completed_at = new Date();
+      if (metadata) r.metadata = metadata;
+      if (db) {
+        await db.query('UPDATE remote_agent_workflow_runs SET status = $1 WHERE id = $2', [
+          'completed',
+          id,
+        ]);
+      }
+    },
+    async failWorkflowRun(id, error) {
+      const r = runs.get(id);
+      if (!r) return;
+      r.status = 'failed';
+      r.completed_at = new Date();
+      r.metadata = { ...r.metadata, error };
+      if (db) {
+        await db.query('UPDATE remote_agent_workflow_runs SET status = $1 WHERE id = $2', [
+          'failed',
+          id,
+        ]);
+      }
+    },
+    async pauseWorkflowRun(id, approvalContext: ApprovalContext) {
+      const r = runs.get(id);
+      if (!r) return;
+      r.status = 'paused';
+      r.metadata = { ...r.metadata, approval: approvalContext };
+    },
+    async cancelWorkflowRun(id) {
+      const r = runs.get(id);
+      if (!r) return;
+      r.status = 'cancelled';
+      r.completed_at = new Date();
+      if (db) {
+        await db.query('UPDATE remote_agent_workflow_runs SET status = $1 WHERE id = $2', [
+          'cancelled',
+          id,
+        ]);
+      }
+    },
+    async createWorkflowEvent() {
+      // no-op
+    },
+    async getCompletedDagNodeOutputs() {
+      return new Map();
+    },
+    async getCodebase() {
+      return null;
+    },
+    async getCodebaseEnvVars() {
+      return {};
+    },
+  };
+  return store;
+}
+
+export interface FakeWebAdapter extends BridgeWebAdapter {
+  /** Map populated by setConversationDbId calls. */
+  readonly dbIds: Map<string, string>;
+}
+
+export function makeFakeWebAdapter(): FakeWebAdapter {
+  const dbIds = new Map<string, string>();
+  return {
+    dbIds,
+    setConversationDbId(platformId, dbId) {
+      dbIds.set(platformId, dbId);
+    },
+    async sendMessage() {
+      // no-op
+    },
+    getStreamingMode() {
+      return 'batch';
+    },
+    getPlatformType() {
+      return 'web';
+    },
+  };
+}
+
+export interface FakeEmitter {
+  subscribe(listener: (event: WorkflowEmitterEvent) => void): () => void;
+  emit(event: WorkflowEmitterEvent): void;
+  /** Active listener count (tests assert on subscription lifecycle). */
+  listenerCount(): number;
+}
+
+export function makeFakeEmitter(): FakeEmitter {
+  const listeners = new Set<(event: WorkflowEmitterEvent) => void>();
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(event) {
+      for (const l of listeners) l(event);
+    },
+    listenerCount() {
+      return listeners.size;
+    },
+  };
+}
+
+export interface RecordedRunWorkflowCall {
+  input: RunWorkflowInput;
+}
+
+export interface FakeBridge {
+  bridge: BridgeDeps;
+  store: FakeStore;
+  platform: FakeWebAdapter;
+  emitter: FakeEmitter;
+  /** All `runWorkflow` invocations in order. */
+  readonly runs: RecordedRunWorkflowCall[];
+  /** Fake codebase rows; keyed by codebase id. Tests preload these. */
+  readonly codebases: Map<string, BridgeCodebase>;
+  /** Conversation ids the dispatcher created. */
+  readonly conversations: BridgeConversation[];
+  /** Override `runWorkflow` to throw or return a different result. */
+  setRunWorkflow(fn: RunWorkflowFn): void;
+  /** Override the workflow resolver. */
+  setResolveWorkflow(fn: (name: string, cwd: string) => Promise<WorkflowDefinition | null>): void;
+}
+
+export function makeFakeBridge(
+  opts: {
+    workflows?: Record<string, WorkflowDefinition>;
+    codebases?: Map<string, BridgeCodebase>;
+    /**
+     * When provided, the bridge writes real `remote_agent_conversations` and
+     * `remote_agent_workflow_runs` rows so the `symphony_dispatches` FK
+     * constraints are satisfied. Pure-unit tests can omit this.
+     */
+    db?: IDatabase;
+  } = {}
+): FakeBridge {
+  const store = makeFakeStore({ db: opts.db });
+  const platform = makeFakeWebAdapter();
+  const emitter = makeFakeEmitter();
+  const codebases = opts.codebases ?? new Map<string, BridgeCodebase>();
+  const conversations: BridgeConversation[] = [];
+  const runs: RecordedRunWorkflowCall[] = [];
+  let convCounter = 0;
+
+  let runWorkflowFn: RunWorkflowFn = async () => {
+    // default: no-op fire-and-forget
+  };
+  let resolveWorkflow: (
+    name: string,
+    cwd: string
+  ) => Promise<WorkflowDefinition | null> = async name => {
+    const wf = opts.workflows?.[name];
+    return wf ?? null;
+  };
+
+  const workflowDeps: WorkflowDeps = {
+    store,
+    getAgentProvider: () => {
+      throw new Error('fake bridge: getAgentProvider not implemented');
+    },
+    loadConfig: async () => ({
+      assistant: 'claude',
+      commands: {},
+      assistants: {
+        claude: {},
+        codex: {},
+      },
+    }),
+  };
+
+  const bridge: BridgeDeps = {
+    workflowDeps,
+    platform,
+    resolveWorkflow: (name, cwd) => resolveWorkflow(name, cwd),
+    loadCodebase: async id => codebases.get(id) ?? null,
+    resolveIsolation: async ({ codebase }) => ({ cwd: `${codebase.default_cwd}/.archon/wt` }),
+    createWorkerConversation: async input => {
+      convCounter += 1;
+      const id = `conv-db-${String(convCounter)}`;
+      const conv: BridgeConversation = {
+        id,
+        platform_conversation_id: input.platformConversationId,
+      };
+      conversations.push(conv);
+      if (opts.db) {
+        await opts.db.query(
+          `INSERT INTO remote_agent_conversations
+             (id, platform_type, platform_conversation_id, codebase_id, cwd)
+           VALUES ($1, $2, $3, $4, $5)`,
+          [id, 'web', input.platformConversationId, input.codebaseId, input.cwd]
+        );
+      }
+      return conv;
+    },
+    runWorkflow: input => {
+      runs.push({ input });
+      return runWorkflowFn(input);
+    },
+  };
+
+  return {
+    bridge,
+    store,
+    platform,
+    emitter,
+    runs,
+    codebases,
+    conversations,
+    setRunWorkflow(fn) {
+      runWorkflowFn = fn;
+    },
+    setResolveWorkflow(fn) {
+      resolveWorkflow = fn;
+    },
+  };
+}
+
+/**
+ * Minimal `WorkflowDefinition` stub — only the fields the dispatcher actually
+ * passes through. Tests that need the full Zod-validated shape should import
+ * from `@archon/workflows/schemas/workflow`.
+ */
+export function makeFakeWorkflowDefinition(name: string): WorkflowDefinition {
+  return {
+    name,
+    description: `Fake ${name}`,
+    nodes: [],
+  } as unknown as WorkflowDefinition;
+}
+
+/** Synthesize a fake `WorkflowExecutionResult` for runWorkflow stubs. */
+export function fakeWorkflowResult(
+  runId: string,
+  success: boolean,
+  message?: string
+): WorkflowExecutionResult {
+  if (success) {
+    return { success: true, workflowRunId: runId, summary: message };
+  }
+  return { success: false, workflowRunId: runId, error: message ?? 'fake failure' };
+}
diff --git a/packages/symphony/src/workflow-bridge/dispatcher.test.ts b/packages/symphony/src/workflow-bridge/dispatcher.test.ts
new file mode 100644
index 0000000000..4a34f364be
--- /dev/null
+++ b/packages/symphony/src/workflow-bridge/dispatcher.test.ts
@@ -0,0 +1,212 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { unlinkSync } from 'fs';
+import { join } from 'path';
+import { SqliteAdapter } from '@archon/core/db/adapters/sqlite';
+import { dispatchToWorkflow } from './dispatcher';
+import { buildSnapshot, type ConfigSnapshot } from '../config/snapshot';
+import { makeIssue } from '../test/fake-tracker';
+import { makeFakeBridge, makeFakeWorkflowDefinition, type FakeBridge } from '../test/fake-bridge';
+import { getDispatchByDispatchKey } from '../db/dispatches';
+
+let dbPath = '';
+let db: SqliteAdapter;
+let fakeBridge: FakeBridge;
+
+function buildSnap(): ConfigSnapshot {
+  return buildSnapshot(
+    {
+      trackers: [
+        {
+          kind: 'github',
+          token: '$GH',
+          owner: 'Ddell12',
+          repo: 'archon-symphony',
+          active_states: ['open'],
+          terminal_states: ['closed'],
+        },
+      ],
+      dispatch: { max_concurrent: 5 },
+      polling: { interval_ms: 30_000 },
+      state_workflow_map: {
+        open: 'archon-feature-development',
+      },
+      codebases: [
+        {
+          tracker: 'github',
+          repository: 'Ddell12/archon-symphony',
+          codebase_id: 'cb-gh',
+        },
+      ],
+    },
+    { GH: 'g' } as NodeJS.ProcessEnv
+  );
+}
+
+describe('dispatchToWorkflow', () => {
+  beforeEach(async () => {
+    dbPath = join(
+      import.meta.dir,
+      `.test-bridge-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+    );
+    db = new SqliteAdapter(dbPath);
+    await db.query(
+      'INSERT INTO remote_agent_codebases (id, name, default_cwd) VALUES ($1, $2, $3)',
+      ['cb-gh', 'GitHub codebase', '/tmp/cb-gh']
+    );
+    fakeBridge = makeFakeBridge({
+      db,
+      codebases: new Map([
+        ['cb-gh', { id: 'cb-gh', name: 'GitHub codebase', default_cwd: '/tmp/cb-gh' }],
+      ]),
+      workflows: {
+        'archon-feature-development': makeFakeWorkflowDefinition('archon-feature-development'),
+      },
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+    for (const suffix of ['', '-wal', '-shm']) {
+      try {
+        unlinkSync(dbPath + suffix);
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  test('launches when codebase + workflow + isolation are all valid', async () => {
+    const snap = buildSnap();
+    const issue = makeIssue({
+      id: 'g-1',
+      identifier: 'Ddell12/archon-symphony#7',
+      state: 'open',
+    });
+    const outcome = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 1,
+      codebaseId: 'cb-gh',
+      abort: new AbortController(),
+    });
+    expect(outcome.status).toBe('launched');
+    expect(outcome.workflowRunId).toBeTruthy();
+    expect(outcome.dispatchId).toBeTruthy();
+
+    const row = await getDispatchByDispatchKey(db, 'github:Ddell12/archon-symphony#7');
+    expect(row).not.toBeNull();
+    expect(row?.status).toBe('running');
+    expect(row?.workflow_run_id).toBe(outcome.workflowRunId ?? '');
+    expect(row?.codebase_id).toBe('cb-gh');
+    expect(row?.workflow_name).toBe('archon-feature-development');
+
+    expect(fakeBridge.runs.length).toBe(1);
+    const run = fakeBridge.runs[0];
+    expect(run?.input.cwd).toBe('/tmp/cb-gh/.archon/wt');
+    expect(run?.input.workerPlatformId).toMatch(/^symphony-github-/);
+    expect(run?.input.preCreatedRunId).toBe(outcome.workflowRunId ?? '');
+    expect(run?.input.codebaseId).toBe('cb-gh');
+
+    expect(fakeBridge.platform.dbIds.has(run?.input.workerPlatformId ?? '')).toBe(true);
+  });
+
+  test('hard-fails with failed_no_codebase when codebaseId is null', async () => {
+    const snap = buildSnap();
+    const issue = makeIssue({
+      id: 'g-2',
+      identifier: 'Ddell12/archon-symphony#8',
+      state: 'open',
+    });
+    const outcome = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 1,
+      codebaseId: null,
+      abort: new AbortController(),
+    });
+    expect(outcome.status).toBe('failed_no_codebase');
+    expect(outcome.reason).toContain('no codebase mapped');
+
+    const row = await getDispatchByDispatchKey(db, 'github:Ddell12/archon-symphony#8');
+    expect(row).not.toBeNull();
+    expect(row?.status).toBe('failed');
+    expect(row?.codebase_id).toBeNull();
+    expect(row?.workflow_run_id).toBeNull();
+    expect(row?.last_error).toContain('no codebase mapped');
+    expect(fakeBridge.runs.length).toBe(0);
+  });
+
+  test('failed_no_workflow when state is unmapped — no DB row, no run', async () => {
+    const snap = buildSnap();
+    const issue = makeIssue({
+      id: 'g-3',
+      identifier: 'Ddell12/archon-symphony#9',
+      state: 'closed', // not in state_workflow_map
+    });
+    const outcome = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 1,
+      codebaseId: 'cb-gh',
+      abort: new AbortController(),
+    });
+    expect(outcome.status).toBe('failed_no_workflow');
+    const row = await getDispatchByDispatchKey(db, 'github:Ddell12/archon-symphony#9');
+    expect(row).toBeNull();
+    expect(fakeBridge.runs.length).toBe(0);
+  });
+
+  test('failed_no_workflow when workflow definition is missing — writes failed row', async () => {
+    const snap = buildSnap();
+    fakeBridge.setResolveWorkflow(async () => null);
+    const issue = makeIssue({
+      id: 'g-4',
+      identifier: 'Ddell12/archon-symphony#10',
+      state: 'open',
+    });
+    const outcome = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 1,
+      codebaseId: 'cb-gh',
+      abort: new AbortController(),
+    });
+    expect(outcome.status).toBe('failed_no_workflow');
+    const row = await getDispatchByDispatchKey(db, 'github:Ddell12/archon-symphony#10');
+    expect(row?.status).toBe('failed');
+    expect(row?.workflow_run_id).toBeNull();
+    expect(row?.last_error).toContain('not found');
+  });
+
+  test('failed_db_conflict when dispatch_key already exists', async () => {
+    const snap = buildSnap();
+    const issue = makeIssue({
+      id: 'g-5',
+      identifier: 'Ddell12/archon-symphony#11',
+      state: 'open',
+    });
+    const first = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 1,
+      codebaseId: 'cb-gh',
+      abort: new AbortController(),
+    });
+    expect(first.status).toBe('launched');
+
+    const second = await dispatchToWorkflow(db, fakeBridge.bridge, {
+      issue,
+      trackerKind: 'github',
+      snap,
+      attempt: 2,
+      codebaseId: 'cb-gh',
+      abort: new AbortController(),
+    });
+    expect(second.status).toBe('failed_db_conflict');
+  });
+});
diff --git a/packages/symphony/src/workflow-bridge/dispatcher.ts b/packages/symphony/src/workflow-bridge/dispatcher.ts
new file mode 100644
index 0000000000..9582c51730
--- /dev/null
+++ b/packages/symphony/src/workflow-bridge/dispatcher.ts
@@ -0,0 +1,345 @@
+/**
+ * Symphony → Archon workflow-run launch.
+ *
+ * Phase 3 replacement for the Phase 2 stub. Given a candidate issue, this:
+ *
+ *   1. Hard-fails if no codebase is mapped (writes a `failed` dispatch row).
+ *   2. Resolves the workflow definition by name from `state_workflow_map`.
+ *   3. Inserts a `pending` dispatch row.
+ *   4. Creates a hidden worker conversation (`platform = 'web'`,
+ *      `platform_conversation_id = symphony-…`) and resolves a worktree.
+ *   5. Pre-creates the workflow_run via the workflow store, attaches its id to
+ *      the dispatch row, transitions the row to `running`.
+ *   6. Fires `executeWorkflow(...)` (fire-and-forget); terminal status comes
+ *      back through the workflow event emitter, handled by the orchestrator.
+ *
+ * The dispatcher does NOT subscribe to events — that's the orchestrator's job
+ * (it owns the in-memory state and the retry scheduler). The dispatcher's
+ * return value tells the orchestrator what state mutation to perform.
+ */
+import type { IDatabase } from '@archon/core/db';
+import { createLogger } from '@archon/paths';
+import { attachWorkflowRun, insertDispatch, updateStatus } from '../db/dispatches';
+import type { Issue } from '../tracker/types';
+import type { ConfigSnapshot, TrackerKind } from '../config/snapshot';
+import type { BridgeDeps, DispatchInput, DispatchOutcome } from './types';
+
+let cachedLog: ReturnType<typeof createLogger> | undefined;
+function getLog(): ReturnType<typeof createLogger> {
+  if (!cachedLog) cachedLog = createLogger('symphony.dispatcher');
+  return cachedLog;
+}
+
+/**
+ * Build a platform conversation id that is filesystem- and URL-safe. Linear
+ * dispatch keys look like `linear:APP-292`; GitHub keys look like
+ * `github:owner/repo#42`. We replace `:`, `/`, and `#` with `-` to stay safe
+ * everywhere.
+ */
+export function buildWorkerPlatformId(
+  dispatchKey: string,
+  timestampMs: number,
+  random: string
+): string {
+  const safe = dispatchKey.replace(/[:/#]+/g, '-');
+  return `symphony-${safe}-${String(timestampMs)}-${random}`;
+}
+
+function repoLabelForIssue(trackerKind: TrackerKind, issue: Issue, snap: ConfigSnapshot): string {
+  if (trackerKind === 'github') {
+    const hash = issue.identifier.indexOf('#');
+    return hash > 0 ? issue.identifier.slice(0, hash) : issue.identifier;
+  }
+  // Linear: `tracker.repository` is the only meaningful repo label upstream.
+  // We surface it here for the no-codebase error message; the orchestrator
+  // already does the codebases[] lookup.
+  const linearCfg = snap.trackers.find(t => t.kind === 'linear');
+  return linearCfg?.kind === 'linear' ? (linearCfg.repository ?? '<no repository>') : '<unknown>';
+}
+
+function renderUserMessage(issue: Issue): string {
+  const lines: string[] = [];
+  lines.push(`# ${issue.identifier}: ${issue.title}`);
+  if (issue.url) lines.push(`URL: ${issue.url}`);
+  if (issue.labels && issue.labels.length > 0) {
+    lines.push(`Labels: ${issue.labels.join(', ')}`);
+  }
+  lines.push('');
+  lines.push(issue.description ?? '');
+  return lines.join('\n').trim();
+}
+
+/**
+ * Launch one issue into the Archon workflow engine.
+ *
+ * Caller (orchestrator) is responsible for:
+ *   - the in-memory `RunningEntry` lifecycle
+ *   - the `runIdToDispatchKey` map for terminal-event reverse lookup
+ *   - retry scheduling on `failed_*` outcomes
+ *
+ * The dispatcher only owns the DB row and the workflow launch sequence.
+ */
+export async function dispatchToWorkflow(
+  db: IDatabase,
+  bridge: BridgeDeps,
+  input: DispatchInput
+): Promise<DispatchOutcome> {
+  const log = getLog();
+  const { issue, trackerKind, snap, attempt, codebaseId } = input;
+  const dispatchKey = `${trackerKind}:${issue.identifier}`;
+
+  // 1. Resolve workflow name + codebase before any DB writes
+  const workflowName = snap.stateWorkflowMap[issue.state];
+  if (!workflowName) {
+    log.warn(
+      { dispatch_key: dispatchKey, identifier: issue.identifier, state: issue.state },
+      'symphony.dispatch_no_workflow_for_state'
+    );
+    return {
+      status: 'failed_no_workflow',
+      reason: `no workflow mapped for state '${issue.state}'`,
+    };
+  }
+
+  // Codebase is required — fail-fast per CLAUDE.md, no fallback to live checkout.
+  if (!codebaseId) {
+    const repo = repoLabelForIssue(trackerKind, issue, snap);
+    const reason = `no codebase mapped for ${trackerKind}:${repo}`;
+    log.warn(
+      {
+        dispatch_key: dispatchKey,
+        identifier: issue.identifier,
+        tracker: trackerKind,
+        repository: repo,
+      },
+      'symphony.dispatch_no_codebase'
+    );
+    try {
+      await insertDispatch(db, {
+        issue_id: issue.id,
+        identifier: issue.identifier,
+        tracker: trackerKind,
+        dispatch_key: dispatchKey,
+        codebase_id: null,
+        workflow_name: workflowName,
+        workflow_run_id: null,
+        attempt,
+        status: 'failed',
+        last_error: reason,
+      });
+    } catch (e) {
+      // Duplicate dispatch_key is the only expected failure. Treat as a
+      // no-op: a previous run already recorded this issue's outcome.
+      log.warn(
+        { dispatch_key: dispatchKey, err: (e as Error).message },
+        'symphony.dispatch_db_conflict'
+      );
+      return { status: 'failed_db_conflict', reason: (e as Error).message };
+    }
+    return { status: 'failed_no_codebase', reason };
+  }
+
+  const codebase = await bridge.loadCodebase(codebaseId);
+  if (!codebase) {
+    const reason = `codebase ${codebaseId} not found`;
+    log.warn(
+      { dispatch_key: dispatchKey, codebase_id: codebaseId },
+      'symphony.dispatch_codebase_missing'
+    );
+    try {
+      await insertDispatch(db, {
+        issue_id: issue.id,
+        identifier: issue.identifier,
+        tracker: trackerKind,
+        dispatch_key: dispatchKey,
+        codebase_id: null,
+        workflow_name: workflowName,
+        workflow_run_id: null,
+        attempt,
+        status: 'failed',
+        last_error: reason,
+      });
+    } catch (e) {
+      log.warn(
+        { dispatch_key: dispatchKey, err: (e as Error).message },
+        'symphony.dispatch_db_conflict'
+      );
+      return { status: 'failed_db_conflict', reason: (e as Error).message };
+    }
+    return { status: 'failed_no_codebase', reason };
+  }
+
+  // 2. Insert pending row before any side-effects so the row is durable even
+  //    if isolation/createWorkflowRun throws.
+  let dispatchId: string;
+  try {
+    const inserted = await insertDispatch(db, {
+      issue_id: issue.id,
+      identifier: issue.identifier,
+      tracker: trackerKind,
+      dispatch_key: dispatchKey,
+      codebase_id: codebaseId,
+      workflow_name: workflowName,
+      workflow_run_id: null,
+      attempt,
+      status: 'pending',
+    });
+    dispatchId = inserted.id;
+  } catch (e) {
+    log.warn(
+      { dispatch_key: dispatchKey, err: (e as Error).message },
+      'symphony.dispatch_db_conflict'
+    );
+    return { status: 'failed_db_conflict', reason: (e as Error).message };
+  }
+
+  // 3. Resolve workflow definition. If discovery fails, mark the row failed.
+  let workflowDefinition;
+  try {
+    workflowDefinition = await bridge.resolveWorkflow(workflowName, codebase.default_cwd);
+  } catch (e) {
+    const reason = `workflow lookup failed: ${(e as Error).message}`;
+    await updateStatus(db, dispatchId, 'failed', reason).catch(() => undefined);
+    log.error(
+      { dispatch_key: dispatchKey, workflow: workflowName, err: (e as Error).message },
+      'symphony.dispatch_workflow_lookup_failed'
+    );
+    return { status: 'failed_no_workflow', reason };
+  }
+  if (!workflowDefinition) {
+    const reason = `workflow '${workflowName}' not found in cwd ${codebase.default_cwd}`;
+    await updateStatus(db, dispatchId, 'failed', reason).catch(() => undefined);
+    log.warn(
+      { dispatch_key: dispatchKey, workflow: workflowName, cwd: codebase.default_cwd },
+      'symphony.dispatch_workflow_missing'
+    );
+    return { status: 'failed_no_workflow', reason };
+  }
+
+  // 4. Create worker conversation + resolve isolation
+  const now = bridge.now ?? Date.now;
+  const platformId = buildWorkerPlatformId(
+    dispatchKey,
+    now(),
+    Math.random().toString(36).slice(2, 8)
+  );
+  let conv;
+  let cwd: string;
+  try {
+    conv = await bridge.createWorkerConversation({
+      platformConversationId: platformId,
+      codebaseId,
+      cwd: codebase.default_cwd,
+    });
+    const isolation = await bridge.resolveIsolation({
+      conversation: conv,
+      codebase,
+      platform: bridge.platform,
+    });
+    cwd = isolation.cwd;
+  } catch (e) {
+    const reason = `worker setup failed: ${(e as Error).message}`;
+    await updateStatus(db, dispatchId, 'failed', reason).catch(() => undefined);
+    log.error(
+      { dispatch_key: dispatchKey, err: (e as Error).message },
+      'symphony.dispatch_worker_setup_failed'
+    );
+    return { status: 'failed_no_workflow', reason };
+  }
+
+  bridge.platform.setConversationDbId(platformId, conv.id);
+
+  // 5. Pre-create the workflow run row, attach it to the dispatch
+  let preCreatedRunId: string;
+  try {
+    const run = await bridge.workflowDeps.store.createWorkflowRun({
+      workflow_name: workflowName,
+      conversation_id: conv.id,
+      codebase_id: codebaseId,
+      user_message: renderUserMessage(issue),
+      working_path: cwd,
+      metadata: {
+        symphony: {
+          dispatch_id: dispatchId,
+          dispatch_key: dispatchKey,
+          tracker: trackerKind,
+          identifier: issue.identifier,
+          attempt,
+        },
+      },
+    });
+    preCreatedRunId = run.id;
+  } catch (e) {
+    const reason = `pre-create run failed: ${(e as Error).message}`;
+    await updateStatus(db, dispatchId, 'failed', reason).catch(() => undefined);
+    log.error(
+      { dispatch_key: dispatchKey, err: (e as Error).message },
+      'symphony.dispatch_pre_create_failed'
+    );
+    return { status: 'failed_no_workflow', reason };
+  }
+
+  try {
+    await attachWorkflowRun(db, dispatchId, preCreatedRunId);
+    await updateStatus(db, dispatchId, 'running');
+  } catch (e) {
+    log.error(
+      { dispatch_key: dispatchKey, err: (e as Error).message },
+      'symphony.dispatch_attach_failed'
+    );
+    // The run row exists upstream but we can't remember it. Surface failure
+    // and let the orchestrator schedule a retry.
+    return {
+      status: 'failed_no_workflow',
+      reason: `attach run id failed: ${(e as Error).message}`,
+    };
+  }
+
+  log.info(
+    {
+      dispatch_id: dispatchId,
+      dispatch_key: dispatchKey,
+      identifier: issue.identifier,
+      tracker: trackerKind,
+      workflow: workflowName,
+      codebase_id: codebaseId,
+      cwd,
+      workflow_run_id: preCreatedRunId,
+      attempt,
+    },
+    'symphony.dispatch_launched'
+  );
+
+  // 6. Fire-and-forget; terminal status arrives via the event emitter, owned
+  //    by the orchestrator's listener.
+  void bridge
+    .runWorkflow({
+      workflow: workflowDefinition,
+      workerPlatformId: platformId,
+      workerConversationDbId: conv.id,
+      cwd,
+      codebaseId,
+      userMessage: renderUserMessage(issue),
+      preCreatedRunId,
+      signal: input.abort.signal,
+    })
+    .catch((err: unknown) => {
+      // executeWorkflow handles its own failures via event emission. Catching
+      // here is belt-and-suspenders for synchronous setup throws inside the
+      // executor wrapper.
+      log.error(
+        {
+          dispatch_id: dispatchId,
+          dispatch_key: dispatchKey,
+          err: err as Error,
+        },
+        'symphony.dispatch_execute_threw'
+      );
+    });
+
+  return {
+    status: 'launched',
+    dispatchId,
+    workflowRunId: preCreatedRunId,
+  };
+}
diff --git a/packages/symphony/src/workflow-bridge/factory.ts b/packages/symphony/src/workflow-bridge/factory.ts
new file mode 100644
index 0000000000..f2ac9b390c
--- /dev/null
+++ b/packages/symphony/src/workflow-bridge/factory.ts
@@ -0,0 +1,141 @@
+/**
+ * Production bridge factory — wires `BridgeDeps` against the real Archon
+ * plumbing. Imported by the server bootstrap so the orchestrator can launch
+ * actual workflow runs.
+ *
+ * The deep imports (`@archon/core/orchestrator/orchestrator`,
+ * `@archon/workflows/executor`, `@archon/core/workflows/store-adapter`) are
+ * intentional: these symbols are not on the stable public surface of
+ * `@archon/core` / `@archon/workflows`, but they are the canonical entry
+ * points used by Archon's own background-dispatch path
+ * (`packages/core/src/orchestrator/orchestrator.ts:dispatchBackgroundWorkflow`).
+ */
+import * as conversationDb from '@archon/core/db/conversations';
+import * as codebaseDb from '@archon/core/db/codebases';
+import { validateAndResolveIsolation } from '@archon/core/orchestrator';
+import { createWorkflowDeps } from '@archon/core/workflows/store-adapter';
+import { loadConfig as loadMergedConfig } from '@archon/core/config';
+import { executeWorkflow } from '@archon/workflows/executor';
+import { discoverWorkflowsWithConfig } from '@archon/workflows/workflow-discovery';
+import type { WorkflowDefinition } from '@archon/workflows/schemas/workflow';
+import { createLogger } from '@archon/paths';
+import type { BridgeCodebase, BridgeDeps, BridgeWebAdapter, RunWorkflowFn } from './types';
+
+let cachedLog: ReturnType<typeof createLogger> | undefined;
+function getLog(): ReturnType<typeof createLogger> {
+  if (!cachedLog) cachedLog = createLogger('symphony.bridge');
+  return cachedLog;
+}
+
+export interface CreateProductionBridgeOptions {
+  webAdapter: BridgeWebAdapter;
+}
+
+export function createProductionBridge(opts: CreateProductionBridgeOptions): BridgeDeps {
+  const workflowDeps = createWorkflowDeps();
+
+  const resolveWorkflow = async (name: string, cwd: string): Promise<WorkflowDefinition | null> => {
+    const result = await discoverWorkflowsWithConfig(cwd, loadMergedConfig);
+    const match = result.workflows.find(w => w.workflow.name === name);
+    return match ? match.workflow : null;
+  };
+
+  const loadCodebase = async (codebaseId: string): Promise<BridgeCodebase | null> => {
+    const cb = await codebaseDb.getCodebase(codebaseId);
+    if (!cb) return null;
+    return { id: cb.id, name: cb.name, default_cwd: cb.default_cwd };
+  };
+
+  const resolveIsolation: BridgeDeps['resolveIsolation'] = async ({
+    conversation,
+    codebase,
+    platform,
+  }) => {
+    // Look up the persisted conversation row — `validateAndResolveIsolation`
+    // expects the full Conversation type, including `isolation_env_id` and
+    // `cwd`. We just created this row, so a fresh fetch is safe.
+    const conv = await conversationDb.findConversationByPlatformId(
+      conversation.platform_conversation_id
+    );
+    if (!conv) {
+      throw new Error(
+        `bridge: worker conversation ${conversation.platform_conversation_id} disappeared between create and isolation resolve`
+      );
+    }
+    const cbFull = await codebaseDb.getCodebase(codebase.id);
+    if (!cbFull) {
+      throw new Error(`bridge: codebase ${codebase.id} disappeared`);
+    }
+    const result = await validateAndResolveIsolation(
+      conv,
+      cbFull,
+      platform as Parameters<typeof validateAndResolveIsolation>[2],
+      conversation.platform_conversation_id,
+      { workflowType: 'thread', workflowId: conversation.platform_conversation_id }
+    );
+    return { cwd: result.cwd };
+  };
+
+  const createWorkerConversation: BridgeDeps['createWorkerConversation'] = async input => {
+    const conv = await conversationDb.getOrCreateConversation(
+      'web',
+      input.platformConversationId,
+      input.codebaseId
+    );
+    await conversationDb.updateConversation(conv.id, {
+      cwd: input.cwd,
+      codebase_id: input.codebaseId,
+      hidden: true,
+    });
+    return { id: conv.id, platform_conversation_id: input.platformConversationId };
+  };
+
+  const runWorkflow: RunWorkflowFn = async input => {
+    const run = await workflowDeps.store.getWorkflowRun(input.preCreatedRunId);
+    if (!run) {
+      // Symphony already wrote the dispatch row with this run id — losing
+      // the row here is unexpected. Surface and bail; the orchestrator's
+      // event listener will never receive a terminal event for this run, so
+      // the dispatch will eventually be reconciled at the next service start.
+      getLog().error(
+        { run_id: input.preCreatedRunId },
+        'symphony.bridge.pre_created_run_disappeared'
+      );
+      return;
+    }
+    try {
+      await executeWorkflow(
+        workflowDeps,
+        opts.webAdapter,
+        input.workerPlatformId,
+        input.cwd,
+        input.workflow,
+        input.userMessage,
+        input.workerConversationDbId,
+        input.codebaseId,
+        undefined,
+        undefined,
+        undefined,
+        run
+      );
+    } catch (err) {
+      // executeWorkflow handles its own failures via the event emitter, but
+      // if we get here something escaped. Surface to logs; the run row is
+      // likely already marked failed by the executor.
+      getLog().error(
+        { err: err as Error, run_id: input.preCreatedRunId },
+        'symphony.bridge.execute_threw'
+      );
+    }
+  };
+
+  return {
+    workflowDeps,
+    platform: opts.webAdapter,
+    resolveWorkflow,
+    loadCodebase,
+    resolveIsolation,
+    createWorkerConversation,
+    runWorkflow,
+  };
+}
diff --git a/packages/symphony/src/workflow-bridge/types.ts b/packages/symphony/src/workflow-bridge/types.ts
new file mode 100644
index 0000000000..ca1e064f23
--- /dev/null
+++ b/packages/symphony/src/workflow-bridge/types.ts
@@ -0,0 +1,120 @@
+/**
+ * Bridge dependency contracts.
+ *
+ * Symphony's dispatcher injects the Archon workflow plumbing through these
+ * narrow interfaces so the orchestrator and dispatcher are unit-testable
+ * without booting the full server. The shapes are structural subsets of the
+ * real Archon types; production wiring satisfies them via direct deep imports
+ * (`@archon/core/orchestrator/orchestrator`, `@archon/workflows/event-emitter`,
+ * etc.) — see `packages/symphony/src/service.ts`.
+ */
+import type { IWorkflowPlatform, WorkflowDeps } from '@archon/workflows/deps';
+import type { WorkflowDefinition } from '@archon/workflows/schemas/workflow';
+import type { Issue } from '../tracker/types';
+import type { ConfigSnapshot, TrackerKind } from '../config/snapshot';
+
+/** Resolves a workflow name (from `state_workflow_map`) to a parsed definition. */
+export type WorkflowResolver = (name: string, cwd: string) => Promise<WorkflowDefinition | null>;
+
+/** Minimal codebase shape needed for isolation resolution + cwd lookup. */
+export interface BridgeCodebase {
+  id: string;
+  name: string;
+  default_cwd: string;
+}
+
+export type CodebaseLoader = (codebaseId: string) => Promise<BridgeCodebase | null>;
+
+/** Worker conversation row created for a Symphony-launched workflow run. */
+export interface BridgeConversation {
+  /** Database UUID. */
+  id: string;
+  /** Platform conversation id (`symphony-…`). */
+  platform_conversation_id: string;
+}
+
+/**
+ * Create-or-fetch a worker conversation row for a Symphony dispatch. Mirrors
+ * `conversationDb.getOrCreateConversation('web', platformId, codebaseId)` plus
+ * `updateConversation(...)` to mark it hidden + set cwd.
+ */
+export type WorkerConversationFactory = (input: {
+  platformConversationId: string;
+  codebaseId: string;
+  cwd: string;
+}) => Promise<BridgeConversation>;
+
+/** Resolves an isolated working directory for a worker conversation. */
+export type IsolationResolver = (input: {
+  conversation: BridgeConversation;
+  codebase: BridgeCodebase;
+  platform: IWorkflowPlatform;
+}) => Promise<{ cwd: string }>;
+
+/** Subset of `WebAdapter` we touch from the bridge. */
+export interface BridgeWebAdapter extends IWorkflowPlatform {
+  /** Required so `executeWorkflow` can persist worker messages to the right DB row. */
+  setConversationDbId(platformConversationId: string, dbId: string): void;
+}
+
+/**
+ * Wires the bridge to the live Archon plumbing. Service-side code constructs
+ * one of these and hands it to the orchestrator at startup. Tests construct a
+ * fake.
+ */
+export interface BridgeDeps {
+  workflowDeps: WorkflowDeps;
+  platform: BridgeWebAdapter;
+  resolveWorkflow: WorkflowResolver;
+  loadCodebase: CodebaseLoader;
+  resolveIsolation: IsolationResolver;
+  createWorkerConversation: WorkerConversationFactory;
+  /**
+   * Calls into `executeWorkflow(...)`. Injected so tests can stub it without
+   * dragging in the real executor (which loads the AI provider stack).
+   * Production passes a thin closure that calls `executeWorkflow` from
+   * `@archon/workflows/executor`.
+   */
+  runWorkflow: RunWorkflowFn;
+  /** Optional clock override for tests. */
+  now?: () => number;
+}
+
+export type RunWorkflowFn = (input: RunWorkflowInput) => Promise<void>;
+
+export interface RunWorkflowInput {
+  workflow: WorkflowDefinition;
+  workerPlatformId: string;
+  workerConversationDbId: string;
+  cwd: string;
+  codebaseId: string;
+  userMessage: string;
+  preCreatedRunId: string;
+  /**
+   * Receives terminal status (`completed` / `failed` / `cancelled`) and the
+   * error message if any. Implementations may resolve before the workflow
+   * actually finishes (fire-and-forget) and rely on the event emitter for
+   * status updates instead — see DispatcherSubscription.
+   */
+  signal: AbortSignal;
+}
+
+export interface DispatchOutcome {
+  status: 'launched' | 'failed_no_codebase' | 'failed_no_workflow' | 'failed_db_conflict';
+  /** Set when status === 'launched'. */
+  workflowRunId?: string;
+  /** Set when status === 'launched'. */
+  dispatchId?: string;
+  /** Set on failed_* outcomes. */
+  reason?: string;
+}
+
+export interface DispatchInput {
+  issue: Issue;
+  trackerKind: TrackerKind;
+  snap: ConfigSnapshot;
+  attempt: number;
+  /** Resolved by the orchestrator before calling the dispatcher. */
+  codebaseId: string | null;
+  abort: AbortController;
+}