@opentag/store 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,9 +1,29 @@
 // src/repository.ts
-import { OpenTagEventSchema, OpenTagRunResultSchema } from "@opentag/core";
-import { and, asc, eq } from "drizzle-orm";
+import {
+  ApprovalDecisionSchema,
+  ApplyIntentOutcomeSchema,
+  ApplyPlanSchema,
+  ActionHintSchema,
+  AdapterMutationMappingSchema,
+  ContextPacketSchema,
+  conversationKeyFromEvent,
+  defaultRunEventMetadata,
+  OpenTagEventSchema,
+  OpenTagRunResultSchema,
+  PolicyRuleSchema,
+  ProposalLineageSchema,
+  preflightMutationIntent,
+  projectTargetRefFromEvent,
+  protocolRunFieldsFromEvent,
+  RunAdmissionDecisionSchema,
+  RunEventImportanceSchema,
+  RunEventVisibilitySchema,
+  SuggestedChangesSnapshotSchema
+} from "@opentag/core";
+import { and, asc, eq, inArray } from "drizzle-orm";
 
 // src/schema.ts
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 var runs = sqliteTable(
   "runs",
   {
@@ -11,9 +31,19 @@ var runs = sqliteTable(
     eventId: text("event_id").notNull(),
     status: text("status").notNull(),
     eventJson: text("event_json").notNull(),
+    contextPacketJson: text("context_packet_json"),
     resultJson: text("result_json"),
     assignedRunnerId: text("assigned_runner_id"),
     executor: text("executor"),
+    parentRunId: text("parent_run_id"),
+    triggeredByActionJson: text("triggered_by_action_json"),
+    sourceProposalId: text("source_proposal_id"),
+    sourceApplyPlanId: text("source_apply_plan_id"),
+    repoProvider: text("repo_provider"),
+    repoOwner: text("repo_owner"),
+    repoName: text("repo_name"),
+    workThreadId: text("work_thread_id"),
+    conversationKey: text("conversation_key"),
     leasedAt: text("leased_at"),
     leaseExpiresAt: text("lease_expires_at"),
     heartbeatAt: text("heartbeat_at"),
@@ -22,14 +52,64 @@ var runs = sqliteTable(
   },
   (table) => ({
     statusIdx: index("runs_status_idx").on(table.status),
-    runnerIdx: index("runs_runner_idx").on(table.assignedRunnerId)
+    runnerIdx: index("runs_runner_idx").on(table.assignedRunnerId),
+    repoIdx: index("runs_repo_idx").on(table.repoProvider, table.repoOwner, table.repoName),
+    workThreadIdx: index("runs_work_thread_idx").on(table.workThreadId),
+    conversationIdx: index("runs_conversation_idx").on(table.conversationKey)
   })
 );
-var runEvents = sqliteTable("run_events", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
+var followUpRequests = sqliteTable(
+  "follow_up_requests",
+  {
+    id: text("id").primaryKey(),
+    sourceEventId: text("source_event_id").notNull(),
+    conversationKey: text("conversation_key").notNull(),
+    activeRunId: text("active_run_id"),
+    eventJson: text("event_json").notNull(),
+    decisionJson: text("decision_json").notNull(),
+    status: text("status").notNull(),
+    createdRunId: text("created_run_id"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (table) => ({
+    sourceEventIdx: uniqueIndex("follow_up_requests_source_event_idx").on(table.sourceEventId),
+    conversationIdx: index("follow_up_requests_conversation_idx").on(table.conversationKey, table.status)
+  })
+);
+var runEvents = sqliteTable(
+  "run_events",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    runId: text("run_id").notNull(),
+    type: text("type").notNull(),
+    visibility: text("visibility").notNull().default("audit"),
+    importance: text("importance").notNull().default("normal"),
+    message: text("message"),
+    payloadJson: text("payload_json").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (table) => ({
+    runIdx: index("run_events_run_idx").on(table.runId)
+  })
+);
+var suggestedChanges = sqliteTable("suggested_changes", {
+  proposalId: text("proposal_id").primaryKey(),
   runId: text("run_id").notNull(),
-  type: text("type").notNull(),
-  payloadJson: text("payload_json").notNull(),
+  snapshotJson: text("snapshot_json").notNull(),
+  createdAt: text("created_at").notNull()
+});
+var approvalDecisions = sqliteTable("approval_decisions", {
+  id: text("id").primaryKey(),
+  proposalId: text("proposal_id").notNull(),
+  decisionJson: text("decision_json").notNull(),
+  createdAt: text("created_at").notNull()
+});
+var applyPlans = sqliteTable("apply_plans", {
+  id: text("id").primaryKey(),
+  proposalId: text("proposal_id").notNull(),
+  approvalDecisionId: text("approval_decision_id").notNull(),
+  planJson: text("plan_json").notNull(),
   createdAt: text("created_at").notNull()
 });
 var runners = sqliteTable("runners", {
@@ -55,18 +135,76 @@ var repoBindings = sqliteTable(
     repoUniqueIdx: uniqueIndex("repo_bindings_provider_owner_repo_idx").on(table.provider, table.owner, table.repo)
   })
 );
-var slackChannelBindings = sqliteTable(
-  "slack_channel_bindings",
+var repoPolicyRules = sqliteTable(
+  "repo_policy_rules",
+  {
+    id: text("id").notNull(),
+    provider: text("provider").notNull(),
+    owner: text("owner").notNull(),
+    repo: text("repo").notNull(),
+    ruleJson: text("rule_json").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.provider, table.owner, table.repo, table.id] })
+  })
+);
+var repoMutationMappings = sqliteTable(
+  "repo_mutation_mappings",
+  {
+    id: text("id").notNull(),
+    provider: text("provider").notNull(),
+    owner: text("owner").notNull(),
+    repo: text("repo").notNull(),
+    mappingJson: text("mapping_json").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.provider, table.owner, table.repo, table.id] })
+  })
+);
+var channelBindings = sqliteTable(
+  "channel_bindings",
   {
     id: integer("id").primaryKey({ autoIncrement: true }),
-    teamId: text("team_id").notNull(),
-    channelId: text("channel_id").notNull(),
+    provider: text("provider").notNull(),
+    accountId: text("account_id").notNull(),
+    conversationId: text("conversation_id").notNull(),
+    repoProvider: text("repo_provider").notNull(),
     owner: text("owner").notNull(),
     repo: text("repo").notNull(),
+    metadataJson: text("metadata_json"),
     createdAt: text("created_at").notNull()
   },
   (table) => ({
-    slackChannelUniqueIdx: uniqueIndex("slack_channel_bindings_team_channel_idx").on(table.teamId, table.channelId)
+    channelBindingUniqueIdx: uniqueIndex("channel_bindings_provider_account_conversation_idx").on(
+      table.provider,
+      table.accountId,
+      table.conversationId
+    )
+  })
+);
+var callbackDeliveries = sqliteTable(
+  "callback_deliveries",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    runId: text("run_id").notNull(),
+    kind: text("kind").notNull(),
+    provider: text("provider").notNull(),
+    uri: text("uri").notNull(),
+    body: text("body").notNull(),
+    threadKey: text("thread_key"),
+    metadataJson: text("metadata_json"),
+    status: text("status").notNull(),
+    attempts: integer("attempts").notNull().default(0),
+    lastError: text("last_error"),
+    nextAttemptAt: text("next_attempt_at"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (table) => ({
+    callbackRunIdx: index("callback_deliveries_run_idx").on(table.runId),
+    callbackStatusIdx: index("callback_deliveries_status_idx").on(table.status)
   })
 );
 function migrateSchema(sqlite) {
@@ -76,9 +214,19 @@ function migrateSchema(sqlite) {
       event_id TEXT NOT NULL,
       status TEXT NOT NULL,
       event_json TEXT NOT NULL,
+      context_packet_json TEXT,
       result_json TEXT,
       assigned_runner_id TEXT,
       executor TEXT,
+      parent_run_id TEXT,
+      triggered_by_action_json TEXT,
+      source_proposal_id TEXT,
+      source_apply_plan_id TEXT,
+      repo_provider TEXT,
+      repo_owner TEXT,
+      repo_name TEXT,
+      work_thread_id TEXT,
+      conversation_key TEXT,
       leased_at TEXT,
       lease_expires_at TEXT,
       heartbeat_at TEXT,
@@ -87,13 +235,37 @@ function migrateSchema(sqlite) {
     );
     CREATE INDEX IF NOT EXISTS runs_status_idx ON runs(status);
     CREATE INDEX IF NOT EXISTS runs_runner_idx ON runs(assigned_runner_id);
+    CREATE INDEX IF NOT EXISTS runs_conversation_idx ON runs(conversation_key);
     CREATE TABLE IF NOT EXISTS run_events (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       run_id TEXT NOT NULL,
       type TEXT NOT NULL,
+      visibility TEXT NOT NULL DEFAULT 'audit',
+      importance TEXT NOT NULL DEFAULT 'normal',
+      message TEXT,
       payload_json TEXT NOT NULL,
       created_at TEXT NOT NULL
     );
+    CREATE INDEX IF NOT EXISTS run_events_run_idx ON run_events(run_id);
+    CREATE TABLE IF NOT EXISTS suggested_changes (
+      proposal_id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      snapshot_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS approval_decisions (
+      id TEXT PRIMARY KEY,
+      proposal_id TEXT NOT NULL,
+      decision_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS apply_plans (
+      id TEXT PRIMARY KEY,
+      proposal_id TEXT NOT NULL,
+      approval_decision_id TEXT NOT NULL,
+      plan_json TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
     CREATE TABLE IF NOT EXISTS runners (
       runner_id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
@@ -113,16 +285,77 @@ function migrateSchema(sqlite) {
     );
     CREATE UNIQUE INDEX IF NOT EXISTS repo_bindings_provider_owner_repo_idx
       ON repo_bindings(provider, owner, repo);
-    CREATE TABLE IF NOT EXISTS slack_channel_bindings (
+    CREATE TABLE IF NOT EXISTS repo_policy_rules (
+      id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      owner TEXT NOT NULL,
+      repo TEXT NOT NULL,
+      rule_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (provider, owner, repo, id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS repo_policy_rules_repo_id_idx
+      ON repo_policy_rules(provider, owner, repo, id);
+    CREATE TABLE IF NOT EXISTS repo_mutation_mappings (
+      id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      owner TEXT NOT NULL,
+      repo TEXT NOT NULL,
+      mapping_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (provider, owner, repo, id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS repo_mutation_mappings_repo_id_idx
+      ON repo_mutation_mappings(provider, owner, repo, id);
+    CREATE TABLE IF NOT EXISTS channel_bindings (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      team_id TEXT NOT NULL,
-      channel_id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      account_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      repo_provider TEXT NOT NULL,
       owner TEXT NOT NULL,
       repo TEXT NOT NULL,
+      metadata_json TEXT,
       created_at TEXT NOT NULL
     );
-    CREATE UNIQUE INDEX IF NOT EXISTS slack_channel_bindings_team_channel_idx
-      ON slack_channel_bindings(team_id, channel_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS channel_bindings_provider_account_conversation_idx
+      ON channel_bindings(provider, account_id, conversation_id);
+    CREATE TABLE IF NOT EXISTS callback_deliveries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      uri TEXT NOT NULL,
+      body TEXT NOT NULL,
+      thread_key TEXT,
+      metadata_json TEXT,
+      status TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT,
+      next_attempt_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS callback_deliveries_run_idx
+      ON callback_deliveries(run_id);
+    CREATE INDEX IF NOT EXISTS callback_deliveries_status_idx
+      ON callback_deliveries(status);
+    CREATE TABLE IF NOT EXISTS follow_up_requests (
+      id TEXT PRIMARY KEY,
+      source_event_id TEXT NOT NULL,
+      conversation_key TEXT NOT NULL,
+      active_run_id TEXT,
+      event_json TEXT NOT NULL,
+      decision_json TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_run_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS follow_up_requests_source_event_idx
+      ON follow_up_requests(source_event_id);
+    CREATE INDEX IF NOT EXISTS follow_up_requests_conversation_idx
+      ON follow_up_requests(conversation_key, status);
   `);
   const columns = sqlite.prepare("PRAGMA table_info(repo_bindings)").all();
   const columnNames = new Set(columns.map((column) => column.name));
@@ -135,14 +368,117 @@ function migrateSchema(sqlite) {
   if (!columnNames.has("allowed_actors_json")) {
     sqlite.exec("ALTER TABLE repo_bindings ADD COLUMN allowed_actors_json TEXT");
   }
+  const channelBindingColumns = sqlite.prepare("PRAGMA table_info(channel_bindings)").all();
+  const channelBindingColumnNames = new Set(channelBindingColumns.map((column) => column.name));
+  if (!channelBindingColumnNames.has("repo_provider")) {
+    sqlite.exec("ALTER TABLE channel_bindings ADD COLUMN repo_provider TEXT");
+    sqlite.exec("UPDATE channel_bindings SET repo_provider = 'github' WHERE repo_provider IS NULL");
+  }
+  if (!channelBindingColumnNames.has("metadata_json")) {
+    sqlite.exec("ALTER TABLE channel_bindings ADD COLUMN metadata_json TEXT");
+  }
   const runColumns = sqlite.prepare("PRAGMA table_info(runs)").all();
   const runColumnNames = new Set(runColumns.map((column) => column.name));
   if (!runColumnNames.has("leased_at")) {
     sqlite.exec("ALTER TABLE runs ADD COLUMN leased_at TEXT");
   }
+  if (!runColumnNames.has("context_packet_json")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN context_packet_json TEXT");
+  }
   if (!runColumnNames.has("heartbeat_at")) {
     sqlite.exec("ALTER TABLE runs ADD COLUMN heartbeat_at TEXT");
   }
+  if (!runColumnNames.has("parent_run_id")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN parent_run_id TEXT");
+  }
+  if (!runColumnNames.has("triggered_by_action_json")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN triggered_by_action_json TEXT");
+  }
+  if (!runColumnNames.has("source_proposal_id")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN source_proposal_id TEXT");
+  }
+  if (!runColumnNames.has("source_apply_plan_id")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN source_apply_plan_id TEXT");
+  }
+  if (!runColumnNames.has("repo_provider")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN repo_provider TEXT");
+  }
+  if (!runColumnNames.has("repo_owner")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN repo_owner TEXT");
+  }
+  if (!runColumnNames.has("repo_name")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN repo_name TEXT");
+  }
+  if (!runColumnNames.has("work_thread_id")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN work_thread_id TEXT");
+  }
+  if (!runColumnNames.has("conversation_key")) {
+    sqlite.exec("ALTER TABLE runs ADD COLUMN conversation_key TEXT");
+  }
+  sqlite.exec("CREATE INDEX IF NOT EXISTS runs_repo_idx ON runs(repo_provider, repo_owner, repo_name)");
+  sqlite.exec("CREATE INDEX IF NOT EXISTS runs_work_thread_idx ON runs(work_thread_id)");
+  sqlite.exec("CREATE INDEX IF NOT EXISTS runs_conversation_idx ON runs(conversation_key)");
+  sqlite.exec(`
+    UPDATE runs
+    SET event_id = event_id || '#duplicate:' || id
+    WHERE rowid NOT IN (
+      SELECT MIN(rowid)
+      FROM runs
+      GROUP BY event_id
+    )
+    AND event_id IN (
+      SELECT event_id
+      FROM runs
+      GROUP BY event_id
+      HAVING COUNT(*) > 1
+    );
+  `);
+  sqlite.exec("CREATE UNIQUE INDEX IF NOT EXISTS runs_source_event_id_idx ON runs(event_id)");
+  const runEventColumns = sqlite.prepare("PRAGMA table_info(run_events)").all();
+  const runEventColumnNames = new Set(runEventColumns.map((column) => column.name));
+  if (!runEventColumnNames.has("visibility")) {
+    sqlite.exec("ALTER TABLE run_events ADD COLUMN visibility TEXT NOT NULL DEFAULT 'audit'");
+  }
+  if (!runEventColumnNames.has("importance")) {
+    sqlite.exec("ALTER TABLE run_events ADD COLUMN importance TEXT NOT NULL DEFAULT 'normal'");
+  }
+  if (!runEventColumnNames.has("message")) {
+    sqlite.exec("ALTER TABLE run_events ADD COLUMN message TEXT");
+  }
+  sqlite.exec("CREATE INDEX IF NOT EXISTS run_events_run_idx ON run_events(run_id)");
+  sqlite.exec("CREATE UNIQUE INDEX IF NOT EXISTS repo_policy_rules_repo_id_idx ON repo_policy_rules(provider, owner, repo, id)");
+  sqlite.exec("CREATE UNIQUE INDEX IF NOT EXISTS repo_mutation_mappings_repo_id_idx ON repo_mutation_mappings(provider, owner, repo, id)");
+  const callbackColumns = sqlite.prepare("PRAGMA table_info(callback_deliveries)").all();
+  const callbackColumnNames = new Set(callbackColumns.map((column) => column.name));
+  if (!callbackColumnNames.has("next_attempt_at")) {
+    sqlite.exec("ALTER TABLE callback_deliveries ADD COLUMN next_attempt_at TEXT");
+  }
+  if (!callbackColumnNames.has("metadata_json")) {
+    sqlite.exec("ALTER TABLE callback_deliveries ADD COLUMN metadata_json TEXT");
+  }
+  const legacySlackTable = sqlite.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'slack_channel_bindings'").get();
+  if (legacySlackTable) {
+    sqlite.exec(`
+      INSERT OR IGNORE INTO channel_bindings (
+        provider,
+        account_id,
+        conversation_id,
+        repo_provider,
+        owner,
+        repo,
+        created_at
+      )
+      SELECT
+        'slack',
+        team_id,
+        channel_id,
+        'github',
+        owner,
+        repo,
+        created_at
+      FROM slack_channel_bindings;
+    `);
+  }
 }
 
 // src/repository.ts
@@ -154,11 +490,21 @@ function isIsoExpired(iso, now) {
   return new Date(iso).getTime() <= now.getTime();
 }
 function runFromRow(row) {
+  const event = OpenTagEventSchema.parse(JSON.parse(row.eventJson));
   const result = row.resultJson ? OpenTagRunResultSchema.parse(JSON.parse(row.resultJson)) : void 0;
+  const triggeredByAction = row.triggeredByActionJson ? ActionHintSchema.parse(JSON.parse(row.triggeredByActionJson)) : void 0;
+  const protocolFields = protocolRunFieldsFromEvent(event, row.createdAt);
+  const contextPacket = row.contextPacketJson ? ContextPacketSchema.parse(JSON.parse(row.contextPacketJson)) : protocolFields.contextPacket;
   return {
     id: row.id,
     eventId: row.eventId,
     status: row.status,
+    ...protocolFields.thread ? { thread: protocolFields.thread } : {},
+    contextPacket,
+    ...row.parentRunId ? { parentRunId: row.parentRunId } : {},
+    ...triggeredByAction ? { triggeredByAction } : {},
+    ...row.sourceProposalId ? { sourceProposalId: row.sourceProposalId } : {},
+    ...row.sourceApplyPlanId ? { sourceApplyPlanId: row.sourceApplyPlanId } : {},
     assignedRunnerId: row.assignedRunnerId ?? void 0,
     executor: row.executor ?? void 0,
     createdAt: row.createdAt,
@@ -166,14 +512,222 @@ function runFromRow(row) {
     ...result ? { result } : {}
   };
 }
-function repoKeyFromEvent(event) {
-  const owner = event.metadata["owner"];
-  const repo = event.metadata["repo"];
-  if (typeof owner !== "string" || typeof repo !== "string") return null;
+function callbackDeliveryFromRow(row) {
+  const metadata = row.metadataJson && typeof row.metadataJson === "string" ? JSON.parse(row.metadataJson) : void 0;
+  return {
+    id: row.id,
+    runId: row.runId,
+    kind: row.kind,
+    provider: row.provider,
+    uri: row.uri,
+    body: row.body,
+    ...row.threadKey ? { threadKey: row.threadKey } : {},
+    ...metadata?.agentId ? { agentId: metadata.agentId } : {},
+    ...metadata?.statusMessageKey ? { statusMessageKey: metadata.statusMessageKey } : {},
+    ...metadata?.blocks ? { blocks: metadata.blocks } : {},
+    status: row.status,
+    attempts: row.attempts,
+    ...row.lastError ? { lastError: row.lastError } : {},
+    ...row.nextAttemptAt ? { nextAttemptAt: row.nextAttemptAt } : {},
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function followUpRequestFromRow(row) {
+  return {
+    id: row.id,
+    sourceEventId: row.sourceEventId,
+    conversationKey: row.conversationKey,
+    ...row.activeRunId ? { activeRunId: row.activeRunId } : {},
+    event: OpenTagEventSchema.parse(JSON.parse(row.eventJson)),
+    decision: RunAdmissionDecisionSchema.parse(JSON.parse(row.decisionJson)),
+    status: row.status,
+    ...row.createdRunId ? { createdRunId: row.createdRunId } : {},
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function runnerFromRow(row) {
   return {
-    provider: typeof event.metadata["repoProvider"] === "string" ? event.metadata["repoProvider"] : "github",
-    owner,
-    repo
+    runnerId: row.runnerId,
+    name: row.name,
+    createdAt: row.createdAt,
+    ...row.heartbeatAt ? { heartbeatAt: row.heartbeatAt } : {}
+  };
+}
+function recordFromJson(value) {
+  if (!value) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function channelBindingFromRow(row) {
+  const metadata = recordFromJson(row.metadataJson);
+  return {
+    provider: row.provider,
+    accountId: row.accountId,
+    conversationId: row.conversationId,
+    repoProvider: row.repoProvider,
+    owner: row.owner,
+    repo: row.repo,
+    ...metadata ? { metadata } : {}
+  };
+}
+function syntheticManualApprovalPolicyRules(decision) {
+  return [
+    {
+      id: `manual_approval_${decision.id}`,
+      scope: "primary_anchor_override",
+      effect: "allow",
+      reason: "Manual approval decision authorized selected proposal intents."
+    }
+  ];
+}
+function executorConditionsFromIntent(intent) {
+  const value = intent.params?.["executorConditions"];
+  if (!Array.isArray(value)) return [];
+  return value.filter((condition) => typeof condition === "string" && condition.length > 0);
+}
+function lineageScopeKey(input) {
+  return input.snapshot.workThread?.id ?? `run:${input.runId}`;
+}
+function computeProposalLineage(snapshots, targetScopeKey) {
+  const scoped = snapshots.filter((snapshot) => lineageScopeKey(snapshot) === targetScopeKey).sort((left, right) => {
+    const timeDelta = new Date(left.snapshot.createdAt).getTime() - new Date(right.snapshot.createdAt).getTime();
+    if (timeDelta !== 0) return timeDelta;
+    return left.snapshot.proposalId.localeCompare(right.snapshot.proposalId);
+  });
+  const latestProposalByDomain = /* @__PURE__ */ new Map();
+  const explicitSupersession = /* @__PURE__ */ new Map();
+  for (const stored of scoped) {
+    const domainsInProposal = /* @__PURE__ */ new Set();
+    for (const intent of stored.snapshot.intents) {
+      domainsInProposal.add(intent.domain);
+      for (const supersededIntentId of intent.supersedesIntentIds ?? []) {
+        explicitSupersession.set(supersededIntentId, { proposalId: stored.snapshot.proposalId, intentId: intent.intentId });
+      }
+    }
+    for (const domain of domainsInProposal) {
+      latestProposalByDomain.set(domain, stored.snapshot.proposalId);
+    }
+  }
+  const entries = [];
+  for (const stored of scoped) {
+    for (const intent of stored.snapshot.intents) {
+      const explicit = explicitSupersession.get(intent.intentId);
+      const latestProposalId = latestProposalByDomain.get(intent.domain);
+      if (explicit) {
+        entries.push({
+          proposalId: stored.snapshot.proposalId,
+          intentId: intent.intentId,
+          domain: intent.domain,
+          status: "superseded",
+          supersededByProposalId: explicit.proposalId,
+          supersededByIntentId: explicit.intentId,
+          reason: "A later intent explicitly superseded this intent."
+        });
+      } else if (latestProposalId && latestProposalId !== stored.snapshot.proposalId) {
+        const supersedingIntent = scoped.find((candidate) => candidate.snapshot.proposalId === latestProposalId)?.snapshot.intents.find((candidateIntent) => candidateIntent.domain === intent.domain);
+        entries.push({
+          proposalId: stored.snapshot.proposalId,
+          intentId: intent.intentId,
+          domain: intent.domain,
+          status: "superseded",
+          supersededByProposalId: latestProposalId,
+          ...supersedingIntent ? { supersededByIntentId: supersedingIntent.intentId } : {},
+          reason: `A newer proposal superseded the ${intent.domain} domain.`
+        });
+      } else {
+        entries.push({
+          proposalId: stored.snapshot.proposalId,
+          intentId: intent.intentId,
+          domain: intent.domain,
+          status: "current"
+        });
+      }
+    }
+  }
+  return ProposalLineageSchema.parse({ scopeKey: targetScopeKey, entries });
+}
+function emptyApplyOutcomeCounts() {
+  return {
+    applied: 0,
+    skipped: 0,
+    failed: 0,
+    stale: 0,
+    unsupported: 0
+  };
+}
+function recordFromUnknown(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function metricsFromEvents(runId, events) {
+  const latestApplyPlans = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "apply_plan.created" && event.type !== "apply_plan.executed") continue;
+    const parsed = ApplyPlanSchema.safeParse(event.payload);
+    if (parsed.success) {
+      latestApplyPlans.set(parsed.data.id, parsed.data);
+    }
+  }
+  const applyOutcomeCounts = emptyApplyOutcomeCounts();
+  for (const plan of latestApplyPlans.values()) {
+    for (const outcome of plan.outcomes ?? []) {
+      applyOutcomeCounts[outcome.outcome] += 1;
+    }
+  }
+  const humanCallbackCount = events.filter((event) => event.visibility === "human" && event.type.startsWith("callback.")).length;
+  const auditEventCount = events.filter((event) => event.visibility === "audit").length;
+  return {
+    runId,
+    totalEventCount: events.length,
+    humanEventCount: events.filter((event) => event.visibility === "human").length,
+    auditEventCount,
+    debugEventCount: events.filter((event) => event.visibility === "debug").length,
+    humanCallbackCount,
+    threadNoiseRatio: auditEventCount === 0 ? humanCallbackCount : humanCallbackCount / auditEventCount,
+    suggestedChangesCount: events.filter((event) => event.type === "proposal.snapshot.created").reduce((count, event) => {
+      const payload = recordFromUnknown(event.payload);
+      const intents = payload?.["intents"];
+      return count + (Array.isArray(intents) ? intents.length : 1);
+    }, 0),
+    approvalDecisionCount: events.filter((event) => event.type === "approval.decision.recorded").length,
+    applyPlanCount: latestApplyPlans.size,
+    childRunCount: events.filter((event) => event.type === "run.child_created").length,
+    applyOutcomeCounts,
+    staleIntentCount: applyOutcomeCounts.stale
+  };
+}
+function aggregateMetrics(input) {
+  const applyOutcomeCounts = emptyApplyOutcomeCounts();
+  for (const run of input.runs) {
+    applyOutcomeCounts.applied += run.applyOutcomeCounts.applied;
+    applyOutcomeCounts.skipped += run.applyOutcomeCounts.skipped;
+    applyOutcomeCounts.failed += run.applyOutcomeCounts.failed;
+    applyOutcomeCounts.stale += run.applyOutcomeCounts.stale;
+    applyOutcomeCounts.unsupported += run.applyOutcomeCounts.unsupported;
+  }
+  const auditEventCount = input.runs.reduce((sum, run) => sum + run.auditEventCount, 0);
+  const humanCallbackCount = input.runs.reduce((sum, run) => sum + run.humanCallbackCount, 0);
+  return {
+    scope: input.scope,
+    scopeId: input.scopeId,
+    runCount: input.runs.length,
+    totalEventCount: input.runs.reduce((sum, run) => sum + run.totalEventCount, 0),
+    humanEventCount: input.runs.reduce((sum, run) => sum + run.humanEventCount, 0),
+    auditEventCount,
+    debugEventCount: input.runs.reduce((sum, run) => sum + run.debugEventCount, 0),
+    humanCallbackCount,
+    threadNoiseRatio: auditEventCount === 0 ? humanCallbackCount : humanCallbackCount / auditEventCount,
+    suggestedChangesCount: input.runs.reduce((sum, run) => sum + run.suggestedChangesCount, 0),
+    approvalDecisionCount: input.runs.reduce((sum, run) => sum + run.approvalDecisionCount, 0),
+    applyPlanCount: input.runs.reduce((sum, run) => sum + run.applyPlanCount, 0),
+    childRunCount: input.runs.reduce((sum, run) => sum + run.childRunCount, 0),
+    applyOutcomeCounts,
+    staleIntentCount: input.runs.reduce((sum, run) => sum + run.staleIntentCount, 0)
   };
 }
 function createOpenTagRepository(db) {
@@ -181,16 +735,227 @@ function createOpenTagRepository(db) {
     await db.insert(runEvents).values({
       runId: input.runId,
       type: input.type,
+      visibility: input.visibility ?? defaultRunEventMetadata(input.type).visibility,
+      importance: input.importance ?? defaultRunEventMetadata(input.type).importance,
+      message: input.message ?? null,
       payloadJson: JSON.stringify(input.payload),
       createdAt: input.createdAt ?? nowIso()
     });
   }
+  async function buildApplyPlan(input) {
+    const storedProposalRow = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, input.proposalId)).limit(1).get();
+    const decisionRow = await db.select().from(approvalDecisions).where(eq(approvalDecisions.id, input.approvalDecisionId)).limit(1).get();
+    const decision = decisionRow ? ApprovalDecisionSchema.parse(JSON.parse(decisionRow.decisionJson)) : null;
+    if (!storedProposalRow || !decision || decision.proposalId !== input.proposalId) return null;
+    const storedProposal = {
+      runId: storedProposalRow.runId,
+      snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(storedProposalRow.snapshotJson))
+    };
+    const runRow = await db.select().from(runs).where(eq(runs.id, storedProposal.runId)).limit(1).get();
+    if (!runRow) return null;
+    const event = OpenTagEventSchema.parse(JSON.parse(runRow.eventJson));
+    const repoKey = projectTargetRefFromEvent(event);
+    const storedPolicyRuleRows = repoKey ? await db.select().from(repoPolicyRules).where(and(eq(repoPolicyRules.provider, repoKey.provider), eq(repoPolicyRules.owner, repoKey.owner), eq(repoPolicyRules.repo, repoKey.repo))).orderBy(asc(repoPolicyRules.createdAt)) : [];
+    const storedPolicyRules = storedPolicyRuleRows.map((row) => PolicyRuleSchema.parse(JSON.parse(row.ruleJson)));
+    const storedMappingRows = repoKey ? await db.select().from(repoMutationMappings).where(
+      and(
+        eq(repoMutationMappings.provider, repoKey.provider),
+        eq(repoMutationMappings.owner, repoKey.owner),
+        eq(repoMutationMappings.repo, repoKey.repo)
+      )
+    ).orderBy(asc(repoMutationMappings.createdAt)) : [];
+    const storedMappings = storedMappingRows.map((row) => AdapterMutationMappingSchema.parse(JSON.parse(row.mappingJson)));
+    const selectedIntentIds = input.selectedIntentIds ?? decision.approvedIntentIds;
+    const approvedIntentIds = new Set(decision.approvedIntentIds);
+    const proposalIntents = new Map(storedProposal.snapshot.intents.map((intent) => [intent.intentId, intent]));
+    const lineageRows = await db.select().from(suggestedChanges).orderBy(asc(suggestedChanges.createdAt));
+    const lineage = computeProposalLineage(
+      lineageRows.map((row) => ({
+        runId: row.runId,
+        snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson))
+      })),
+      lineageScopeKey(storedProposal)
+    );
+    const actionabilityByIntentId = new Map(lineage.entries.map((entry) => [entry.intentId, entry]));
+    const policyRules = [...storedPolicyRules, ...input.policyRules ?? [], ...syntheticManualApprovalPolicyRules(decision)];
+    const outcomes = selectedIntentIds.map((intentId) => {
+      if (!approvedIntentIds.has(intentId)) {
+        return {
+          intentId,
+          outcome: "skipped",
+          message: "Intent was not approved by the approval decision."
+        };
+      }
+      const intent = proposalIntents.get(intentId);
+      if (!intent) {
+        return {
+          intentId,
+          outcome: "failed",
+          message: "Intent does not exist on the referenced proposal."
+        };
+      }
+      const actionability = actionabilityByIntentId.get(intentId);
+      if (actionability?.status !== "current") {
+        return {
+          intentId,
+          outcome: "stale",
+          message: actionability?.reason ?? "Intent is no longer current for its mutation domain."
+        };
+      }
+      return preflightMutationIntent({
+        intent,
+        permissions: event.permissions,
+        policyRules,
+        executorConditions: executorConditionsFromIntent(intent),
+        ...input.adapter ? { adapter: input.adapter } : {}
+      }).outcome;
+    });
+    return {
+      runId: storedProposal.runId,
+      createdAt: nowIso(),
+      plan: ApplyPlanSchema.parse({
+        id: input.id,
+        proposalId: input.proposalId,
+        approvalDecisionId: input.approvalDecisionId,
+        selectedIntentIds,
+        ...input.adapter ? { adapter: input.adapter } : {},
+        adapterPlan: {
+          semantics: "preflight first, then per-intent outcome",
+          externalWritesExecuted: false,
+          mappings: storedMappings
+        },
+        outcomes
+      })
+    };
+  }
+  function applyPlanCreatedEventRow(input) {
+    return {
+      runId: input.runId,
+      type: "apply_plan.created",
+      visibility: "audit",
+      importance: "high",
+      message: `Created apply plan for ${input.plan.selectedIntentIds.length} intent(s).`,
+      payloadJson: JSON.stringify(input.plan),
+      createdAt: input.createdAt
+    };
+  }
+  async function appendApplyPlanCreatedEvent(input) {
+    await db.insert(runEvents).values(applyPlanCreatedEventRow(input));
+  }
   return {
     appendRunEvent,
+    async getRunByEventId(input) {
+      const row = await db.select().from(runs).where(eq(runs.eventId, input.eventId)).limit(1).get();
+      if (!row) return null;
+      return {
+        run: runFromRow(row),
+        event: OpenTagEventSchema.parse(JSON.parse(row.eventJson))
+      };
+    },
+    async findActiveRunForConversation(input) {
+      const row = await db.select().from(runs).where(and(eq(runs.conversationKey, input.conversationKey), inArray(runs.status, ["assigned", "running"]))).orderBy(asc(runs.createdAt)).limit(1).get();
+      if (!row) return null;
+      return {
+        run: runFromRow(row),
+        event: OpenTagEventSchema.parse(JSON.parse(row.eventJson))
+      };
+    },
+    async createFollowUpRequest(input) {
+      const event = OpenTagEventSchema.parse(input.event);
+      const decision = RunAdmissionDecisionSchema.parse(input.decision);
+      const createdAt = nowIso();
+      const conversationKey = conversationKeyFromEvent(event);
+      const insertResult = await db.insert(followUpRequests).values({
+        id: input.id,
+        sourceEventId: event.id,
+        conversationKey,
+        activeRunId: input.activeRunId ?? null,
+        eventJson: JSON.stringify(event),
+        decisionJson: JSON.stringify(decision),
+        status: "queued",
+        createdRunId: null,
+        createdAt,
+        updatedAt: createdAt
+      }).onConflictDoNothing({ target: followUpRequests.sourceEventId });
+      if (insertResult.changes === 0) {
+        const existing = await db.select().from(followUpRequests).where(eq(followUpRequests.sourceEventId, event.id)).limit(1).get();
+        if (!existing) {
+          throw new Error(`Follow-up request already exists for event ${event.id}, but it could not be loaded`);
+        }
+        return { followUpRequest: followUpRequestFromRow(existing), created: false };
+      }
+      const created = await db.select().from(followUpRequests).where(eq(followUpRequests.id, input.id)).limit(1).get();
+      if (!created) {
+        throw new Error(`Follow-up request ${input.id} was created but could not be loaded`);
+      }
+      return { followUpRequest: followUpRequestFromRow(created), created: true };
+    },
+    async getFollowUpRequest(input) {
+      const row = await db.select().from(followUpRequests).where(eq(followUpRequests.id, input.id)).limit(1).get();
+      return row ? followUpRequestFromRow(row) : null;
+    },
+    async createRunFromFollowUpRequest(input) {
+      const row = await db.select().from(followUpRequests).where(eq(followUpRequests.id, input.followUpRequestId)).limit(1).get();
+      if (!row) {
+        throw new Error(`Follow-up request not found: ${input.followUpRequestId}`);
+      }
+      if (row.status !== "queued") {
+        throw new Error(`Follow-up request ${input.followUpRequestId} is not queued.`);
+      }
+      const updatedAt = nowIso();
+      const promoteResult = await db.update(followUpRequests).set({
+        status: "promoting",
+        updatedAt
+      }).where(and(eq(followUpRequests.id, input.followUpRequestId), eq(followUpRequests.status, "queued")));
+      if (promoteResult.changes === 0) {
+        throw new Error(`Follow-up request ${input.followUpRequestId} is not queued.`);
+      }
+      const followUp = followUpRequestFromRow({ ...row, status: "promoting", updatedAt });
+      try {
+        const { run, created } = await this.createRun({
+          id: input.runId,
+          event: followUp.event,
+          ...followUp.activeRunId ? { parentRunId: followUp.activeRunId } : {}
+        });
+        if (!created) {
+          throw new Error(`Run already exists for follow-up request ${input.followUpRequestId}.`);
+        }
+        await db.update(followUpRequests).set({
+          status: "promoted",
+          createdRunId: run.id,
+          updatedAt
+        }).where(eq(followUpRequests.id, input.followUpRequestId));
+        const updated = await db.select().from(followUpRequests).where(eq(followUpRequests.id, input.followUpRequestId)).limit(1).get();
+        if (!updated) {
+          throw new Error(`Follow-up request ${input.followUpRequestId} was promoted but could not be loaded`);
+        }
+        if (followUp.activeRunId) {
+          await appendRunEvent({
+            runId: followUp.activeRunId,
+            type: "follow_up_request.promoted",
+            payload: { followUpRequestId: followUp.id, createdRunId: run.id, sourceEventId: followUp.sourceEventId },
+            visibility: "audit",
+            importance: "normal",
+            createdAt: updatedAt
+          });
+        }
+        return { followUpRequest: followUpRequestFromRow(updated), run };
+      } catch (error) {
+        await db.update(followUpRequests).set({
+          status: "queued",
+          updatedAt: nowIso()
+        }).where(and(eq(followUpRequests.id, input.followUpRequestId), eq(followUpRequests.status, "promoting")));
+        throw error;
+      }
+    },
     async registerRunner(input) {
       const createdAt = nowIso();
       await db.insert(runners).values({ runnerId: input.runnerId, name: input.name, createdAt }).onConflictDoNothing();
     },
+    async getRunner(input) {
+      const row = await db.select().from(runners).where(eq(runners.runnerId, input.runnerId)).limit(1).get();
+      return row ? runnerFromRow(row) : null;
+    },
     async createRepoBinding(input) {
       await db.insert(repoBindings).values({
         ...input,
@@ -208,16 +973,87 @@ function createOpenTagRepository(db) {
         }
       });
     },
+    async upsertRepoPolicyRule(input) {
+      const rule = PolicyRuleSchema.parse(input.rule);
+      const createdAt = nowIso();
+      await db.insert(repoPolicyRules).values({
+        id: rule.id,
+        provider: input.provider,
+        owner: input.owner,
+        repo: input.repo,
+        ruleJson: JSON.stringify(rule),
+        createdAt
+      }).onConflictDoUpdate({
+        target: [repoPolicyRules.provider, repoPolicyRules.owner, repoPolicyRules.repo, repoPolicyRules.id],
+        set: {
+          ruleJson: JSON.stringify(rule),
+          createdAt
+        }
+      });
+      return rule;
+    },
+    async listRepoPolicyRules(input) {
+      const rows = await db.select().from(repoPolicyRules).where(and(eq(repoPolicyRules.provider, input.provider), eq(repoPolicyRules.owner, input.owner), eq(repoPolicyRules.repo, input.repo))).orderBy(asc(repoPolicyRules.createdAt));
+      return rows.map((row) => PolicyRuleSchema.parse(JSON.parse(row.ruleJson)));
+    },
+    async upsertRepoMutationMapping(input) {
+      const mapping = AdapterMutationMappingSchema.parse(input.mapping);
+      const createdAt = nowIso();
+      await db.insert(repoMutationMappings).values({
+        id: mapping.id,
+        provider: input.provider,
+        owner: input.owner,
+        repo: input.repo,
+        mappingJson: JSON.stringify(mapping),
+        createdAt
+      }).onConflictDoUpdate({
+        target: [repoMutationMappings.provider, repoMutationMappings.owner, repoMutationMappings.repo, repoMutationMappings.id],
+        set: {
+          mappingJson: JSON.stringify(mapping),
+          createdAt
+        }
+      });
+      return mapping;
+    },
+    async listRepoMutationMappings(input) {
+      const rows = await db.select().from(repoMutationMappings).where(and(eq(repoMutationMappings.provider, input.provider), eq(repoMutationMappings.owner, input.owner), eq(repoMutationMappings.repo, input.repo))).orderBy(asc(repoMutationMappings.createdAt));
+      return rows.map((row) => AdapterMutationMappingSchema.parse(JSON.parse(row.mappingJson)));
+    },
+    async upsertChannelBinding(input) {
+      await db.insert(channelBindings).values({
+        provider: input.provider,
+        accountId: input.accountId,
+        conversationId: input.conversationId,
+        repoProvider: input.repoProvider,
+        owner: input.owner,
+        repo: input.repo,
+        metadataJson: input.metadata ? JSON.stringify(input.metadata) : null,
+        createdAt: nowIso()
+      }).onConflictDoUpdate({
+        target: [channelBindings.provider, channelBindings.accountId, channelBindings.conversationId],
+        set: {
+          repoProvider: input.repoProvider,
+          owner: input.owner,
+          repo: input.repo,
+          metadataJson: input.metadata ? JSON.stringify(input.metadata) : null
+        }
+      });
+    },
     async createSlackChannelBinding(input) {
-      await db.insert(slackChannelBindings).values({
-        teamId: input.teamId,
-        channelId: input.channelId,
+      const repoProvider = input.repoProvider ?? "github";
+      await db.insert(channelBindings).values({
+        provider: "slack",
+        accountId: input.teamId,
+        conversationId: input.channelId,
+        repoProvider,
         owner: input.owner,
         repo: input.repo,
+        metadataJson: null,
         createdAt: nowIso()
       }).onConflictDoUpdate({
-        target: [slackChannelBindings.teamId, slackChannelBindings.channelId],
+        target: [channelBindings.provider, channelBindings.accountId, channelBindings.conversationId],
         set: {
+          repoProvider,
           owner: input.owner,
           repo: input.repo
         }
@@ -225,32 +1061,132 @@ function createOpenTagRepository(db) {
     },
     async createRun(input) {
       const event = OpenTagEventSchema.parse(input.event);
+      const triggeredByAction = input.triggeredByAction ? ActionHintSchema.parse(input.triggeredByAction) : void 0;
       const createdAt = nowIso();
-      await db.insert(runs).values({
+      const protocolFields = protocolRunFieldsFromEvent(event, createdAt);
+      const repoKey = projectTargetRefFromEvent(event);
+      const insertResult = await db.insert(runs).values({
         id: input.id,
         eventId: event.id,
         status: "queued",
         eventJson: JSON.stringify(event),
+        contextPacketJson: JSON.stringify(protocolFields.contextPacket),
+        parentRunId: input.parentRunId ?? null,
+        triggeredByActionJson: triggeredByAction ? JSON.stringify(triggeredByAction) : null,
+        sourceProposalId: input.sourceProposalId ?? null,
+        sourceApplyPlanId: input.sourceApplyPlanId ?? null,
+        repoProvider: repoKey?.provider ?? null,
+        repoOwner: repoKey?.owner ?? null,
+        repoName: repoKey?.repo ?? null,
+        workThreadId: protocolFields.thread?.id ?? null,
+        conversationKey: conversationKeyFromEvent(event),
         createdAt,
         updatedAt: createdAt
+      }).onConflictDoNothing({ target: runs.eventId });
+      if (insertResult.changes === 0) {
+        const existingBySourceEvent = await db.select().from(runs).where(eq(runs.eventId, event.id)).limit(1).get();
+        if (!existingBySourceEvent) {
+          throw new Error(`Run already exists for event ${event.id}, but it could not be loaded`);
+        }
+        const replayDecision = RunAdmissionDecisionSchema.parse({
+          action: "drop_duplicate",
+          reason: "Source event already created a run.",
+          reasonCode: "duplicate_source_event",
+          decidedAt: createdAt,
+          activeRunId: existingBySourceEvent.id,
+          eventId: event.id
+        });
+        await appendRunEvent({
+          runId: existingBySourceEvent.id,
+          type: "admission.decided",
+          payload: replayDecision,
+          visibility: "audit",
+          importance: "normal",
+          message: replayDecision.reason,
+          createdAt
+        });
+        await appendRunEvent({
+          runId: existingBySourceEvent.id,
+          type: "run.create_idempotent_replay",
+          payload: { requestedRunId: input.id, eventId: event.id },
+          visibility: "audit",
+          importance: "low",
+          createdAt
+        });
+        return { run: runFromRow(existingBySourceEvent), created: false };
+      }
+      const createDecision = RunAdmissionDecisionSchema.parse({
+        action: "start",
+        reason: "Source event accepted and ready to create a run.",
+        reasonCode: "new_event",
+        decidedAt: createdAt,
+        eventId: event.id
+      });
+      await appendRunEvent({
+        runId: input.id,
+        type: "admission.decided",
+        payload: createDecision,
+        visibility: "audit",
+        importance: "normal",
+        message: createDecision.reason,
+        createdAt
       });
       await appendRunEvent({
         runId: input.id,
         type: "run.created",
         payload: { eventId: event.id },
+        visibility: "audit",
+        importance: "low",
+        createdAt
+      });
+      await appendRunEvent({
+        runId: input.id,
+        type: "context_packet.generated",
+        payload: {
+          contextPacket: protocolFields.contextPacket,
+          ...protocolFields.thread ? { thread: protocolFields.thread } : {}
+        },
+        visibility: "audit",
+        importance: "normal",
+        message: protocolFields.contextPacket.summary,
         createdAt
       });
+      if (input.parentRunId) {
+        await appendRunEvent({
+          runId: input.parentRunId,
+          type: "run.child_created",
+          payload: {
+            childRunId: input.id,
+            ...triggeredByAction ? { triggeredByAction } : {},
+            ...input.sourceProposalId ? { sourceProposalId: input.sourceProposalId } : {},
+            ...input.sourceApplyPlanId ? { sourceApplyPlanId: input.sourceApplyPlanId } : {}
+          },
+          visibility: "audit",
+          importance: "normal",
+          message: `Created child run ${input.id}.`,
+          createdAt
+        });
+      }
       return {
-        id: input.id,
-        eventId: event.id,
-        status: "queued",
-        createdAt,
-        updatedAt: createdAt
+        run: {
+          id: input.id,
+          eventId: event.id,
+          status: "queued",
+          ...protocolFields,
+          ...input.parentRunId ? { parentRunId: input.parentRunId } : {},
+          ...triggeredByAction ? { triggeredByAction } : {},
+          ...input.sourceProposalId ? { sourceProposalId: input.sourceProposalId } : {},
+          ...input.sourceApplyPlanId ? { sourceApplyPlanId: input.sourceApplyPlanId } : {},
+          contextPacket: protocolFields.contextPacket,
+          createdAt,
+          updatedAt: createdAt
+        },
+        created: true
       };
     },
     async claimNextRun(input) {
       const now = /* @__PURE__ */ new Date();
-      const activeRows = await db.select().from(runs).where(and(eq(runs.status, "assigned"))).orderBy(asc(runs.createdAt));
+      const activeRows = await db.select().from(runs).where(inArray(runs.status, ["assigned", "running"])).orderBy(asc(runs.createdAt));
       for (const activeRow of activeRows) {
         if (!isIsoExpired(activeRow.leaseExpiresAt, now)) continue;
         const updatedAt2 = nowIso();
@@ -266,13 +1202,15 @@ function createOpenTagRepository(db) {
           runId: activeRow.id,
           type: "run.lease_expired",
           payload: { previousRunnerId: activeRow.assignedRunnerId, previousLeaseExpiresAt: activeRow.leaseExpiresAt },
+          visibility: "audit",
+          importance: "normal",
           createdAt: updatedAt2
         });
       }
       const queuedRows = await db.select().from(runs).where(eq(runs.status, "queued")).orderBy(asc(runs.createdAt));
       const row = queuedRows.find((candidate) => {
         const event = OpenTagEventSchema.parse(JSON.parse(candidate.eventJson));
-        const repoKey = repoKeyFromEvent(event);
+        const repoKey = projectTargetRefFromEvent(event);
         if (!repoKey) return false;
         const binding = db.select().from(repoBindings).where(
           and(
@@ -288,28 +1226,35 @@ function createOpenTagRepository(db) {
       const updatedAt = nowIso();
       const leasedAt = updatedAt;
       const leaseExpiresAt = new Date(Date.now() + input.leaseSeconds * 1e3).toISOString();
-      await db.update(runs).set({
+      const updateResult = await db.update(runs).set({
         status: "assigned",
         assignedRunnerId: input.runnerId,
         leasedAt,
         leaseExpiresAt,
         heartbeatAt: leasedAt,
         updatedAt
-      }).where(eq(runs.id, row.id));
+      }).where(and(eq(runs.id, row.id), eq(runs.status, "queued")));
+      if (updateResult.changes === 0) {
+        return null;
+      }
       await appendRunEvent({
         runId: row.id,
         type: "run.claimed",
         payload: { runnerId: input.runnerId, leasedAt, leaseExpiresAt },
+        visibility: "audit",
+        importance: "normal",
         createdAt: updatedAt
       });
       return {
         run: {
-          id: row.id,
-          eventId: row.eventId,
+          ...runFromRow({
+            ...row,
+            status: "assigned",
+            assignedRunnerId: input.runnerId,
+            updatedAt
+          }),
           status: "assigned",
           assignedRunnerId: input.runnerId,
-          executor: row.executor ?? void 0,
-          createdAt: row.createdAt,
           updatedAt
         },
         event: OpenTagEventSchema.parse(JSON.parse(row.eventJson))
@@ -330,14 +1275,32 @@ function createOpenTagRepository(db) {
         ...row.allowedActorsJson ? { allowedActors: JSON.parse(row.allowedActorsJson) } : {}
       };
     },
+    async getChannelBinding(input) {
+      const row = await db.select().from(channelBindings).where(
+        and(
+          eq(channelBindings.provider, input.provider),
+          eq(channelBindings.accountId, input.accountId),
+          eq(channelBindings.conversationId, input.conversationId)
+        )
+      ).limit(1).get();
+      return row ? channelBindingFromRow(row) : null;
+    },
     async getSlackChannelBinding(input) {
-      const row = await db.select().from(slackChannelBindings).where(and(eq(slackChannelBindings.teamId, input.teamId), eq(slackChannelBindings.channelId, input.channelId))).limit(1).get();
+      const row = await db.select().from(channelBindings).where(
+        and(
+          eq(channelBindings.provider, "slack"),
+          eq(channelBindings.accountId, input.teamId),
+          eq(channelBindings.conversationId, input.channelId)
+        )
+      ).limit(1).get();
       if (!row) return null;
+      const binding = channelBindingFromRow(row);
       return {
-        teamId: row.teamId,
-        channelId: row.channelId,
-        owner: row.owner,
-        repo: row.repo
+        teamId: binding.accountId,
+        channelId: binding.conversationId,
+        repoProvider: binding.repoProvider,
+        owner: binding.owner,
+        repo: binding.repo
       };
     },
     async heartbeat(input) {
@@ -351,42 +1314,311 @@ function createOpenTagRepository(db) {
         runId: input.runId,
         type: "run.heartbeat",
         payload: { runnerId: input.runnerId, heartbeatAt: updatedAt, leaseExpiresAt },
+        visibility: "debug",
+        importance: "low",
         createdAt: updatedAt
       });
       return true;
     },
     async markRunning(input) {
       const updatedAt = nowIso();
-      await db.update(runs).set({ status: "running", executor: input.executor, updatedAt }).where(eq(runs.id, input.runId));
+      const conditions = [eq(runs.id, input.runId)];
+      if (input.runnerId) {
+        conditions.push(eq(runs.assignedRunnerId, input.runnerId));
+      }
+      const updateResult = await db.update(runs).set({ status: "running", executor: input.executor, updatedAt }).where(and(...conditions));
+      if (updateResult.changes === 0) {
+        return false;
+      }
       await appendRunEvent({
         runId: input.runId,
         type: "run.running",
-        payload: { executor: input.executor },
+        payload: input.runnerId ? { runnerId: input.runnerId, executor: input.executor } : { executor: input.executor },
+        visibility: "audit",
+        importance: "normal",
         createdAt: updatedAt
       });
+      return true;
     },
     async completeRun(input) {
       const result = OpenTagRunResultSchema.parse(input.result);
       const updatedAt = nowIso();
-      const status = result.conclusion === "success" ? "succeeded" : result.conclusion === "cancelled" ? "cancelled" : "failed";
-      await db.update(runs).set({ status, resultJson: JSON.stringify(result), updatedAt }).where(eq(runs.id, input.runId));
+      const status = result.conclusion === "success" ? "succeeded" : result.conclusion === "cancelled" ? "cancelled" : result.conclusion === "needs_human" ? "needs_approval" : "failed";
+      const runRow = await db.select().from(runs).where(eq(runs.id, input.runId)).limit(1).get();
+      if (!runRow) {
+        if (input.runnerId) return false;
+        throw new Error(`Run not found: ${input.runId}`);
+      }
+      if (input.runnerId && runRow.assignedRunnerId !== input.runnerId) {
+        return false;
+      }
+      const runThread = runRow ? protocolRunFieldsFromEvent(OpenTagEventSchema.parse(JSON.parse(runRow.eventJson)), runRow.createdAt).thread : void 0;
+      await db.update(runs).set({
+        status,
+        resultJson: JSON.stringify(result),
+        assignedRunnerId: null,
+        leasedAt: null,
+        leaseExpiresAt: null,
+        heartbeatAt: null,
+        updatedAt
+      }).where(input.runnerId ? and(eq(runs.id, input.runId), eq(runs.assignedRunnerId, input.runnerId)) : eq(runs.id, input.runId));
+      for (const snapshot of result.suggestedChanges ?? []) {
+        const parsedSnapshot = SuggestedChangesSnapshotSchema.parse({
+          ...snapshot,
+          sourceRunId: snapshot.sourceRunId ?? input.runId,
+          ...snapshot.workThread || !runThread ? {} : { workThread: runThread }
+        });
+        await db.insert(suggestedChanges).values({
+          proposalId: parsedSnapshot.proposalId,
+          runId: input.runId,
+          snapshotJson: JSON.stringify(parsedSnapshot),
+          createdAt: parsedSnapshot.createdAt
+        }).onConflictDoUpdate({
+          target: suggestedChanges.proposalId,
+          set: {
+            runId: input.runId,
+            snapshotJson: JSON.stringify(parsedSnapshot),
+            createdAt: parsedSnapshot.createdAt
+          }
+        });
+        await appendRunEvent({
+          runId: input.runId,
+          type: "proposal.snapshot.created",
+          payload: parsedSnapshot,
+          visibility: "audit",
+          importance: "high",
+          message: parsedSnapshot.summary,
+          createdAt: updatedAt
+        });
+      }
       await appendRunEvent({
         runId: input.runId,
         type: "run.completed",
         payload: result,
+        visibility: "audit",
+        importance: "high",
+        message: result.summary,
         createdAt: updatedAt
       });
+      if ((result.suggestedChanges?.length ?? 0) > 0 || (result.artifacts?.length ?? 0) > 0) {
+        await appendRunEvent({
+          runId: input.runId,
+          type: "success_metric.observed",
+          payload: {
+            metric: "time_to_first_useful_artifact",
+            artifactCount: result.artifacts?.length ?? 0,
+            suggestedChangesCount: result.suggestedChanges?.length ?? 0
+          },
+          visibility: "audit",
+          importance: "normal",
+          createdAt: updatedAt
+        });
+      }
+      return true;
+    },
+    async getSuggestedChanges(input) {
+      const row = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, input.proposalId)).limit(1).get();
+      if (!row) return null;
+      return {
+        runId: row.runId,
+        snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson))
+      };
+    },
+    async listSuggestedChangesForRun(input) {
+      const rows = await db.select().from(suggestedChanges).where(eq(suggestedChanges.runId, input.runId)).orderBy(asc(suggestedChanges.createdAt));
+      return rows.map((row) => SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson)));
+    },
+    async listLatestSuggestedChangesForConversation(input) {
+      const runRows = await db.select().from(runs).where(eq(runs.conversationKey, input.conversationKey)).orderBy(asc(runs.createdAt));
+      for (const runRow of [...runRows].reverse()) {
+        const proposalRows = await db.select().from(suggestedChanges).where(eq(suggestedChanges.runId, runRow.id)).orderBy(asc(suggestedChanges.createdAt));
+        if (proposalRows.length === 0) continue;
+        const run = runFromRow(runRow);
+        const event = OpenTagEventSchema.parse(JSON.parse(runRow.eventJson));
+        return proposalRows.map((row) => ({
+          runId: row.runId,
+          run,
+          event,
+          snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson))
+        }));
+      }
+      return [];
+    },
+    async getProposalLineage(input) {
+      const targetRow = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, input.proposalId)).limit(1).get();
+      if (!targetRow) return null;
+      const target = {
+        runId: targetRow.runId,
+        snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(targetRow.snapshotJson))
+      };
+      const rows = await db.select().from(suggestedChanges).orderBy(asc(suggestedChanges.createdAt));
+      const snapshots = rows.map((row) => ({
+        runId: row.runId,
+        snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson))
+      }));
+      return computeProposalLineage(snapshots, lineageScopeKey(target));
+    },
+    async listCurrentMutationIntents(input) {
+      const targetRow = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, input.proposalId)).limit(1).get();
+      if (!targetRow) return null;
+      const rows = await db.select().from(suggestedChanges).orderBy(asc(suggestedChanges.createdAt));
+      const lineage = computeProposalLineage(
+        rows.map((row) => ({
+          runId: row.runId,
+          snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(row.snapshotJson))
+        })),
+        lineageScopeKey({
+          runId: targetRow.runId,
+          snapshot: SuggestedChangesSnapshotSchema.parse(JSON.parse(targetRow.snapshotJson))
+        })
+      );
+      if (!lineage) return null;
+      return lineage.entries.filter((entry) => entry.status === "current");
+    },
+    async recordApprovalDecision(input) {
+      const decision = ApprovalDecisionSchema.parse(input);
+      const storedProposalRow = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, decision.proposalId)).limit(1).get();
+      if (!storedProposalRow) return null;
+      await db.insert(approvalDecisions).values({
+        id: decision.id,
+        proposalId: decision.proposalId,
+        decisionJson: JSON.stringify(decision),
+        createdAt: decision.approvedAt
+      }).onConflictDoUpdate({
+        target: approvalDecisions.id,
+        set: {
+          proposalId: decision.proposalId,
+          decisionJson: JSON.stringify(decision),
+          createdAt: decision.approvedAt
+        }
+      });
+      await appendRunEvent({
+        runId: storedProposalRow.runId,
+        type: "approval.decision.recorded",
+        payload: decision,
+        visibility: "audit",
+        importance: "high",
+        message: `Approved ${decision.approvedIntentIds.length} intent(s).`,
+        createdAt: decision.approvedAt
+      });
+      await appendRunEvent({
+        runId: storedProposalRow.runId,
+        type: "success_metric.observed",
+        payload: {
+          metric: "external_write_approval_rate",
+          proposalId: decision.proposalId,
+          approvedIntentCount: decision.approvedIntentIds.length
+        },
+        visibility: "audit",
+        importance: "normal",
+        createdAt: decision.approvedAt
+      });
+      return decision;
+    },
+    async getApprovalDecision(input) {
+      const row = await db.select().from(approvalDecisions).where(eq(approvalDecisions.id, input.id)).limit(1).get();
+      return row ? ApprovalDecisionSchema.parse(JSON.parse(row.decisionJson)) : null;
+    },
+    async createApplyPlan(input) {
+      const built = await buildApplyPlan(input);
+      if (!built) return null;
+      await db.insert(applyPlans).values({
+        id: built.plan.id,
+        proposalId: built.plan.proposalId,
+        approvalDecisionId: built.plan.approvalDecisionId,
+        planJson: JSON.stringify(built.plan),
+        createdAt: built.createdAt
+      }).onConflictDoUpdate({
+        target: applyPlans.id,
+        set: {
+          proposalId: built.plan.proposalId,
+          approvalDecisionId: built.plan.approvalDecisionId,
+          planJson: JSON.stringify(built.plan),
+          createdAt: built.createdAt
+        }
+      });
+      await appendApplyPlanCreatedEvent(built);
+      return built.plan;
+    },
+    async createApplyPlanOnce(input) {
+      const built = await buildApplyPlan(input);
+      if (!built) return null;
+      const result = db.transaction((tx) => {
+        const insertResult = tx.insert(applyPlans).values({
+          id: built.plan.id,
+          proposalId: built.plan.proposalId,
+          approvalDecisionId: built.plan.approvalDecisionId,
+          planJson: JSON.stringify(built.plan),
+          createdAt: built.createdAt
+        }).onConflictDoNothing({ target: applyPlans.id }).run();
+        if (insertResult.changes === 0) {
+          return { created: false };
+        }
+        tx.insert(runEvents).values(applyPlanCreatedEventRow(built)).run();
+        return { created: true };
+      });
+      if (!result.created) {
+        const existing = await db.select().from(applyPlans).where(eq(applyPlans.id, input.id)).limit(1).get();
+        if (!existing) {
+          throw new Error(`Apply plan ${input.id} already exists but could not be loaded`);
+        }
+        return { plan: ApplyPlanSchema.parse(JSON.parse(existing.planJson)), created: false };
+      }
+      return { plan: built.plan, created: true };
+    },
+    async getApplyPlan(input) {
+      const row = await db.select().from(applyPlans).where(eq(applyPlans.id, input.id)).limit(1).get();
+      return row ? ApplyPlanSchema.parse(JSON.parse(row.planJson)) : null;
+    },
+    async updateApplyPlanOutcomes(input) {
+      const row = await db.select().from(applyPlans).where(eq(applyPlans.id, input.id)).limit(1).get();
+      if (!row) return null;
+      const currentPlan = ApplyPlanSchema.parse(JSON.parse(row.planJson));
+      const outcomes = input.outcomes.map((outcome) => ApplyIntentOutcomeSchema.parse(outcome));
+      const updatedPlan = ApplyPlanSchema.parse({
+        ...currentPlan,
+        adapterPlan: {
+          ...currentPlan.adapterPlan && typeof currentPlan.adapterPlan === "object" && !Array.isArray(currentPlan.adapterPlan) ? currentPlan.adapterPlan : {},
+          externalWritesExecuted: input.externalWritesExecuted
+        },
+        outcomes
+      });
+      const updatedAt = nowIso();
+      await db.update(applyPlans).set({ planJson: JSON.stringify(updatedPlan), createdAt: row.createdAt }).where(eq(applyPlans.id, input.id));
+      const storedProposalRow = await db.select().from(suggestedChanges).where(eq(suggestedChanges.proposalId, updatedPlan.proposalId)).limit(1).get();
+      if (storedProposalRow) {
+        await appendRunEvent({
+          runId: storedProposalRow.runId,
+          type: "apply_plan.executed",
+          payload: updatedPlan,
+          visibility: "audit",
+          importance: "high",
+          message: `Executed apply plan with ${outcomes.length} outcome(s).`,
+          createdAt: updatedAt
+        });
+      }
+      return updatedPlan;
     },
     async recordProgress(input) {
+      if (input.runnerId) {
+        const row = await db.select().from(runs).where(and(eq(runs.id, input.runId), eq(runs.assignedRunnerId, input.runnerId))).limit(1).get();
+        if (!row) return false;
+      }
       await appendRunEvent({
         runId: input.runId,
         type: "run.progress",
         payload: {
+          ...input.runnerId ? { runnerId: input.runnerId } : {},
           type: input.type ?? "progress",
           message: input.message,
           at: input.at ?? nowIso()
-        }
+        },
+        visibility: input.visibility ?? "audit",
+        importance: input.importance ?? "normal",
+        message: input.message,
+        createdAt: input.at ?? nowIso()
       });
+      return true;
     },
     async getRun(input) {
       const row = await db.select().from(runs).where(eq(runs.id, input.runId)).limit(1).get();
@@ -402,19 +1634,196 @@ function createOpenTagRepository(db) {
         id: row.id,
         runId: row.runId,
         type: row.type,
+        visibility: RunEventVisibilitySchema.parse(row.visibility),
+        importance: RunEventImportanceSchema.parse(row.importance),
+        ...row.message ? { message: row.message } : {},
+        payload: JSON.parse(row.payloadJson),
+        createdAt: row.createdAt
+      }));
+    },
+    async enqueueCallbackDelivery(input) {
+      const createdAt = nowIso();
+      const rows = await db.insert(callbackDeliveries).values({
+        runId: input.runId,
+        kind: input.kind,
+        provider: input.provider,
+        uri: input.uri,
+        body: input.body,
+        threadKey: input.threadKey ?? null,
+        metadataJson: JSON.stringify({
+          ...input.agentId ? { agentId: input.agentId } : {},
+          ...input.statusMessageKey ? { statusMessageKey: input.statusMessageKey } : {},
+          ...input.blocks ? { blocks: input.blocks } : {}
+        }),
+        status: "pending",
+        createdAt,
+        updatedAt: createdAt
+      }).returning();
+      const row = rows[0];
+      if (!row) throw new Error("callback delivery was not created");
+      await appendRunEvent({
+        runId: input.runId,
+        type: `callback.${input.kind}.queued`,
+        payload: callbackDeliveryFromRow(row),
+        visibility: "audit",
+        importance: "normal",
+        createdAt
+      });
+      return callbackDeliveryFromRow(row);
+    },
+    async markCallbackDelivered(input) {
+      const updatedAt = nowIso();
+      const row = await db.select().from(callbackDeliveries).where(eq(callbackDeliveries.id, input.deliveryId)).limit(1).get();
+      if (!row) return;
+      await db.update(callbackDeliveries).set({ status: "delivered", attempts: row.attempts + 1, lastError: null, nextAttemptAt: null, updatedAt }).where(eq(callbackDeliveries.id, input.deliveryId));
+      await appendRunEvent({
+        runId: row.runId,
+        type: `callback.${row.kind}.delivered`,
+        payload: { ...callbackDeliveryFromRow(row), status: "delivered", attempts: row.attempts + 1, updatedAt },
+        visibility: "human",
+        importance: row.kind === "final" ? "high" : "normal",
+        message: row.body,
+        createdAt: updatedAt
+      });
+    },
+    async markCallbackFailed(input) {
+      const updatedAt = nowIso();
+      const row = await db.select().from(callbackDeliveries).where(eq(callbackDeliveries.id, input.deliveryId)).limit(1).get();
+      if (!row) return;
+      await db.update(callbackDeliveries).set({ status: "failed", attempts: row.attempts + 1, lastError: input.error, nextAttemptAt: input.nextAttemptAt ?? null, updatedAt }).where(eq(callbackDeliveries.id, input.deliveryId));
+      await appendRunEvent({
+        runId: row.runId,
+        type: `callback.${row.kind}.failed`,
+        payload: {
+          ...callbackDeliveryFromRow(row),
+          status: "failed",
+          attempts: row.attempts + 1,
+          lastError: input.error,
+          ...input.nextAttemptAt ? { nextAttemptAt: input.nextAttemptAt } : {},
+          updatedAt
+        },
+        visibility: "audit",
+        importance: "normal",
+        createdAt: updatedAt
+      });
+    },
+    async listPendingCallbackDeliveries(input) {
+      const now = input.now ?? /* @__PURE__ */ new Date();
+      const maxAttempts = input.maxAttempts ?? Number.POSITIVE_INFINITY;
+      const rows = await db.select().from(callbackDeliveries).where(inArray(callbackDeliveries.status, ["pending", "failed"])).orderBy(asc(callbackDeliveries.id));
+      return rows.map(callbackDeliveryFromRow).filter((delivery) => delivery.attempts < maxAttempts).filter((delivery) => !delivery.nextAttemptAt || new Date(delivery.nextAttemptAt).getTime() <= now.getTime()).slice(0, input.limit);
+    },
+    async claimPendingCallbackDeliveries(input) {
+      const now = input.now ?? /* @__PURE__ */ new Date();
+      const maxAttempts = input.maxAttempts ?? Number.POSITIVE_INFINITY;
+      const staleThresholdMs = input.staleDeliveryThresholdMs ?? 6e4;
+      const staleDeliveryCutoff = new Date(now.getTime() - staleThresholdMs).toISOString();
+      const rows = await db.select().from(callbackDeliveries).where(inArray(callbackDeliveries.status, ["pending", "failed", "delivering"])).orderBy(asc(callbackDeliveries.id));
+      const claimed = [];
+      for (const row of rows) {
+        const delivery = callbackDeliveryFromRow(row);
+        if (delivery.attempts >= maxAttempts) continue;
+        if (delivery.nextAttemptAt && new Date(delivery.nextAttemptAt).getTime() > now.getTime()) continue;
+        if (row.status === "delivering" && row.updatedAt > staleDeliveryCutoff) continue;
+        const updatedAt = input.now ? input.now.toISOString() : nowIso();
+        const claimWhere = row.status === "delivering" ? and(eq(callbackDeliveries.id, row.id), eq(callbackDeliveries.status, "delivering"), eq(callbackDeliveries.updatedAt, row.updatedAt)) : and(eq(callbackDeliveries.id, row.id), inArray(callbackDeliveries.status, ["pending", "failed"]));
+        const claimResult = await db.update(callbackDeliveries).set({ status: "delivering", updatedAt }).where(claimWhere);
+        if (claimResult.changes === 0) continue;
+        claimed.push({
+          ...delivery,
+          status: "delivering",
+          updatedAt
+        });
+        if (claimed.length >= input.limit) break;
+      }
+      return claimed;
+    },
+    async getRunMetrics(input) {
+      const rows = await db.select().from(runEvents).where(eq(runEvents.runId, input.runId)).orderBy(asc(runEvents.id));
+      const events = rows.map((row) => ({
+        id: row.id,
+        runId: row.runId,
+        type: row.type,
+        visibility: RunEventVisibilitySchema.parse(row.visibility),
+        importance: RunEventImportanceSchema.parse(row.importance),
+        ...row.message ? { message: row.message } : {},
         payload: JSON.parse(row.payloadJson),
         createdAt: row.createdAt
       }));
+      return metricsFromEvents(input.runId, events);
+    },
+    async getRepoMetrics(input) {
+      const runRows = await db.select().from(runs).where(and(eq(runs.repoProvider, input.provider), eq(runs.repoOwner, input.owner), eq(runs.repoName, input.repo))).orderBy(asc(runs.createdAt));
+      const matchingRunIds = runRows.map((row) => row.id);
+      const runMetrics = [];
+      for (const runId of matchingRunIds) {
+        const rows = await db.select().from(runEvents).where(eq(runEvents.runId, runId)).orderBy(asc(runEvents.id));
+        runMetrics.push(
+          metricsFromEvents(
+            runId,
+            rows.map((row) => ({
+              id: row.id,
+              runId: row.runId,
+              type: row.type,
+              visibility: RunEventVisibilitySchema.parse(row.visibility),
+              importance: RunEventImportanceSchema.parse(row.importance),
+              ...row.message ? { message: row.message } : {},
+              payload: JSON.parse(row.payloadJson),
+              createdAt: row.createdAt
+            }))
+          )
+        );
+      }
+      return aggregateMetrics({
+        scope: "repo",
+        scopeId: `${input.provider}:${input.owner}/${input.repo}`,
+        runs: runMetrics
+      });
+    },
+    async getWorkThreadMetrics(input) {
+      const runRows = await db.select().from(runs).where(eq(runs.workThreadId, input.threadId)).orderBy(asc(runs.createdAt));
+      const matchingRunIds = runRows.map((row) => row.id);
+      const runMetrics = [];
+      for (const runId of matchingRunIds) {
+        const rows = await db.select().from(runEvents).where(eq(runEvents.runId, runId)).orderBy(asc(runEvents.id));
+        runMetrics.push(
+          metricsFromEvents(
+            runId,
+            rows.map((row) => ({
+              id: row.id,
+              runId: row.runId,
+              type: row.type,
+              visibility: RunEventVisibilitySchema.parse(row.visibility),
+              importance: RunEventImportanceSchema.parse(row.importance),
+              ...row.message ? { message: row.message } : {},
+              payload: JSON.parse(row.payloadJson),
+              createdAt: row.createdAt
+            }))
+          )
+        );
+      }
+      return aggregateMetrics({
+        scope: "work_thread",
+        scopeId: input.threadId,
+        runs: runMetrics
+      });
     }
   };
 }
 export {
+  applyPlans,
+  approvalDecisions,
+  callbackDeliveries,
+  channelBindings,
   createOpenTagRepository,
+  followUpRequests,
   migrateSchema,
   repoBindings,
+  repoMutationMappings,
+  repoPolicyRules,
   runEvents,
   runners,
   runs,
-  slackChannelBindings
+  suggestedChanges
 };
 //# sourceMappingURL=index.js.map