forge-workflow 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/forge-issues.js

@@ -1,371 +1,23 @@
 'use strict';
 
-const { spawn } = require('node:child_process');
-const { existsSync } = require('node:fs');
 const path = require('node:path');
-const { isBeadsInitialized } = require('./beads-setup');
-const { BeadsIssueAdapter } = require('./adapters/beads-issue-adapter');
 const { KernelIssueAdapter } = require('./adapters/kernel-issue-adapter');
 const { createGitHubProjectionPlan } = require('./issue-sync/project-github');
 const { createLocalBroker, buildLocalBrokerConfig } = require('./kernel/broker');
 const { createBuiltinSQLiteDriver } = require('./kernel/sqlite-driver');
-const { shouldUseKernelBroker } = require('./issue-backend');
 const { detectWorktree } = require('./detect-worktree');
 const { DEFAULT_LEASE_TTL_MS } = require('./kernel/lease-enforcer');
 
-const OPERATION_TO_BD = {
-  create: 'create',
-  list: 'list',
-  ready: 'ready',
-  show: 'show',
-  search: 'search',
-  stats: 'status',
-  close: 'close',
-  update: 'update',
-  comment: 'comments',
-  // KAP-7/KAP-12 derived reads: identity passthroughs to the matching bd subcommand.
-  // Routed here (not in _issue.js) so the issue command surface carries no bd args.
-  blocked: 'blocked',
-  stale: 'stale',
-  orphans: 'orphans',
-  lint: 'lint',
-  // Epic support: identity passthrough to `bd children` for the beads opt-out. The
-  // kernel default emits the richer `issue.children` rollup; this passthrough only
-  // keeps the beads path from a null-deref when children is invoked under --issue-backend
-  // beads (the bd output shape differs and carries no rollup).
-  children: 'children',
-};
-
-// Beads has no verified release operation; the claim lease lives only in the Kernel
-// backend. Surfaced as an explicit error so `forge release <id>` on the beads opt-out
-// fails loudly instead of silently mapping to an unrelated bd subcommand.
-const BEADS_RELEASE_KERNEL_ONLY_ERROR =
-  'forge release <id> is defined for the Kernel issue backend; Beads passthrough has no verified release operation.';
-
-// `bd children` emits a different payload (no rollup) than the kernel
-// `issue.children` envelope this command promises. Reject the beads backend
-// explicitly instead of silently proxying a contract-violating shape.
-const BEADS_CHILDREN_KERNEL_ONLY_ERROR =
-  'forge issue children is defined for the Kernel issue backend; Beads passthrough has no equivalent issue.children rollup.';
-
-// Lease ownership lives only in the Kernel backend (kernel_claims); Beads has no
-// verified lease to check. Reject the beads path explicitly so `forge issue owns <id>`
-// fails loudly instead of mapping to an unrelated/absent Beads subcommand.
-const BEADS_OWNS_KERNEL_ONLY_ERROR =
-  'forge issue owns <id> is defined for the Kernel issue backend; Beads passthrough has no lease-ownership verification.';
-
-// Active leases live only in the Kernel backend (kernel_claims); Beads has no lease
-// table to enumerate. Reject the beads path explicitly so `forge claims` fails loudly
-// instead of mapping to an absent Beads subcommand.
-const BEADS_CLAIMS_KERNEL_ONLY_ERROR =
-  'forge claims is defined for the Kernel issue backend; Beads passthrough has no active-lease listing.';
-
 const OPERATION_METHOD_ALIASES = {
   'dep.add': 'depAdd',
   'dep.remove': 'depRemove',
 };
 
-function getSpawnOptions(projectRoot) {
-  return {
-    cwd: projectRoot,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  };
-}
-
-function getPathEntries(env = process.env, delimiter = path.delimiter) {
-  const rawPath = env.PATH || env.Path || '';
-  return rawPath
-    .split(delimiter)
-    .map(entry => entry.trim().replace(/^"(.*)"$/, '$1'))
-    .filter(Boolean);
-}
-
-function resolveWindowsCommandCandidates(commandNames, deps = {}) {
-  const env = deps.env || process.env;
-  const fileExists = deps.existsSync || existsSync;
-  const resolved = [];
-  const seen = new Set();
-  const pathEntries = getPathEntries(env, ';');
-
-  for (const dir of pathEntries) {
-    for (const commandName of commandNames) {
-      const fullPath = isWindowsPathEntry(dir)
-        ? path.win32.join(dir, commandName)
-        : path.posix.join(dir, commandName);
-      const dedupeKey = fullPath.toLowerCase();
-      if (!seen.has(dedupeKey) && fileExists(fullPath)) {
-        seen.add(dedupeKey);
-        resolved.push(fullPath);
-      }
-    }
-  }
-
-  return resolved;
-}
-
-function isWindowsPathEntry(entry = '') {
-  return /^(?:[a-zA-Z]:[\\/]|\\\\)/.test(entry) || entry.includes('\\');
-}
-
-function getBdCommandCandidates(deps = {}) {
-  const platform = deps.platform || process.platform;
-  if (platform === 'win32') {
-    const resolved = resolveWindowsCommandCandidates(['bd.exe', 'bd.cmd'], deps);
-    return [...new Set([...resolved, 'bd.exe', 'bd'])];
-  }
-
-  return ['bd'];
-}
-
-function normalizeExecOutput(output) {
-  if (typeof output === 'string') {
-    return output;
-  }
-
-  if (Buffer.isBuffer(output)) {
-    return output.toString('utf8');
-  }
-
-  return '';
-}
-
-function hasBdSoftFailure(output) {
-  return /(^|\n)Error(?: resolving| updating| fetching| adding)?\b/i.test(output);
-}
-
-function hasEmptyShowPayload(operation, output) {
-  if (operation !== 'show') {
-    return false;
-  }
-
-  const trimmedOutput = output.trim();
-  return trimmedOutput === '' || trimmedOutput === '[]' || trimmedOutput === 'null';
-}
-
+// Backend-agnostic: a `--help`/`-h` invocation must never reach a store.
 function isHelpInvocation(args = []) {
   return args.includes('--help') || args.includes('-h');
 }
 
-function extractErrorMessage(error) {
-  if (error?.code === 'ENOENT') {
-    return 'Beads (bd) command not found. Install or initialize Beads before using forge issues.';
-  }
-
-  return error?.message?.trim() || 'Beads command failed';
-}
-
-function getCommandErrorMessage(result) {
-  const output = [result?.stdout, result?.stderr].filter(Boolean).join('\n').trim();
-  if (output) {
-    return output;
-  }
-
-  if (typeof result?.code === 'number') {
-    return `Beads command failed with exit code ${result.code}`;
-  }
-
-  return 'Beads command failed';
-}
-
-function buildBdArgs(operation, args) {
-  if (operation === 'comment') {
-    return ['comments', 'add', ...args];
-  }
-
-  // De-bead parity: `forge claim <id>` maps to bd `update <id> --claim`. The
-  // translation lived in _issue.js; it now lives in the beads layer so the issue
-  // command surface stays free of bd argv. The issue id is the first positional.
-  if (operation === 'claim') {
-    const [issueId, ...rest] = args;
-    if (!issueId) {
-      return { error: 'Missing issue id. Usage: forge claim <id> [bd-update-flags]' };
-    }
-    return ['update', issueId, '--claim', ...rest];
-  }
-
-  if (operation === 'dep.add') {
-    return ['dep', 'add', ...args];
-  }
-
-  if (operation === 'dep.remove') {
-    return ['dep', 'remove', ...args];
-  }
-
-  const bdCommand = OPERATION_TO_BD[operation];
-  if (!bdCommand) {
-    return null;
-  }
-
-  return [bdCommand, ...args];
-}
-
-function shouldCaptureOutput(operation, args, deps = {}) {
-  if (deps.captureOutput === true) {
-    return true;
-  }
-
-  if (isHelpInvocation(args)) {
-    return true;
-  }
-
-  if (args.includes('--json')) {
-    return true;
-  }
-
-  return operation === 'update' || operation === 'show';
-}
-
-async function runBdCommand(operation, args, projectRoot, deps = {}) {
-  const spawnBd = deps.spawn || spawn;
-  const stdoutTarget = deps.stdout || process.stdout;
-  const stderrTarget = deps.stderr || process.stderr;
-  const captureOutput = shouldCaptureOutput(operation, args.slice(1), deps);
-  const commandCandidates = deps.commandCandidates || getBdCommandCandidates(deps);
-  let lastError;
-
-  for (const command of commandCandidates) {
-    try {
-      return await new Promise((resolve, reject) => {
-        const child = spawnBd(command, args, getSpawnOptions(projectRoot));
-        let stdout = '';
-        let stderr = '';
-
-        child.stdout?.setEncoding?.('utf8');
-        child.stderr?.setEncoding?.('utf8');
-        child.stdout?.on?.('data', chunk => {
-          const normalizedChunk = normalizeExecOutput(chunk);
-          if (captureOutput) {
-            stdout += normalizedChunk;
-          } else {
-            stdoutTarget?.write?.(normalizedChunk);
-          }
-        });
-        child.stderr?.on?.('data', chunk => {
-          const normalizedChunk = normalizeExecOutput(chunk);
-          if (captureOutput) {
-            stderr += normalizedChunk;
-          }
-          stderrTarget?.write?.(normalizedChunk);
-        });
-
-        child.on('error', reject);
-        child.on('close', code => {
-          resolve({
-            code,
-            stdout,
-            stderr,
-          });
-        });
-      });
-    } catch (error) {
-      lastError = error;
-      // ENOENT/EINVAL means this candidate is not directly spawnable — try next.
-      if (error?.code !== 'ENOENT' && error?.code !== 'EINVAL') {
-        throw error;
-      }
-    }
-  }
-
-  throw lastError;
-}
-
-async function runBeadsOperation(operation, args, context, deps) {
-  // Beads has no verified release; fail before the init check so the kernel-only
-  // contract is reported even in an uninitialized repo (parity with the old
-  // _issue.js release guard, which short-circuited on the beads path).
-  if (operation === 'release' && !isHelpInvocation(args)) {
-    return { success: false, error: BEADS_RELEASE_KERNEL_ONLY_ERROR };
-  }
-
-  // `children` only has a verified shape on the kernel backend (the
-  // issue.children rollup); fail loudly rather than proxy `bd children`.
-  if (operation === 'children' && !isHelpInvocation(args)) {
-    return { success: false, error: BEADS_CHILDREN_KERNEL_ONLY_ERROR };
-  }
-
-  // `owns` verifies a Kernel lease; Beads has no such lease. Fail loudly rather
-  // than silently proxy to a non-existent Beads subcommand.
-  if (operation === 'owns' && !isHelpInvocation(args)) {
-    return { success: false, error: BEADS_OWNS_KERNEL_ONLY_ERROR };
-  }
-
-  // `claims` enumerates the Kernel lease table; Beads has none. Fail loudly rather
-  // than silently proxy to a non-existent Beads subcommand.
-  if (operation === 'claims' && !isHelpInvocation(args)) {
-    return { success: false, error: BEADS_CLAIMS_KERNEL_ONLY_ERROR };
-  }
-
-  const checkInit = deps.isBeadsInitialized || isBeadsInitialized;
-  if (!isHelpInvocation(args) && !checkInit(context.projectRoot)) {
-    return {
-      success: false,
-      error: 'Beads is not initialized in this project. Run forge setup before using forge issues.',
-    };
-  }
-
-  const bdArgs = buildBdArgs(operation, args);
-  // A non-array result is a translation error (e.g. claim with no issue id).
-  if (!Array.isArray(bdArgs)) {
-    return { success: false, error: bdArgs.error };
-  }
-  // The reported operation is the logical operation name (comment -> 'comment',
-  // show -> 'show'), NOT the bd subcommand argv[0] (which is 'comments'/'status').
-  // The one exception is claim: it maps to `update <id> --claim`, and the historical
-  // _issue.js beads path reported operation 'update', so preserve that here.
-  const reportedOperation = operation === 'claim' ? 'update' : operation;
-  const runCommand = deps.runBdCommand || ((cmdArgs, projectRoot) => runBdCommand(operation, cmdArgs, projectRoot, deps));
-
-  try {
-    const result = await runCommand(bdArgs, context.projectRoot);
-    const stdout = normalizeExecOutput(result?.stdout);
-    const stderr = normalizeExecOutput(result?.stderr);
-    const combinedOutput = [stdout, stderr].filter(Boolean).join('\n');
-
-    if (result?.code !== 0) {
-      return {
-        success: false,
-        error: getCommandErrorMessage(result),
-      };
-    }
-
-    if (hasBdSoftFailure(combinedOutput)) {
-      return {
-        success: false,
-        error: combinedOutput.trim() || 'Beads command failed',
-      };
-    }
-
-    if (hasEmptyShowPayload(operation, combinedOutput)) {
-      return {
-        success: false,
-        error: `Issue not found: ${args[0] || 'unknown issue'}`,
-      };
-    }
-
-    return {
-      success: true,
-      operation: reportedOperation,
-      output: stdout,
-      stderr,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: extractErrorMessage(error),
-    };
-  }
-}
-
-function createBeadsIssueBackend(deps = {}) {
-  return new BeadsIssueAdapter({
-    runBeadsOperation: (operation, args, context, contextDeps = {}) =>
-      runBeadsOperation(operation, args, context, {
-        ...deps,
-        ...contextDeps,
-      }),
-  });
-}
-
 // Build the default local broker for the CLI path. createLocalBroker does NOT
 // construct a driver on its own (`const driver = options.driver`), so when no
 // driver is injected we build a builtin SQLite driver pointed at the resolved
@@ -450,11 +102,9 @@ function createKernelIssueBackend(context = {}) {
 }
 
 function createIssueService({ backend } = {}) {
-  // Default issue backend is now the Kernel. Beads is reachable opt-OUT via the
-  // selector (--issue-backend beads / FORGE_ISSUE_BACKEND=beads / config), which
-  // resolves to an explicit `backend` upstream in runIssueOperation. This no-arg
-  // fallback fires only for a no-backend direct call to createIssueService — the
-  // CLI path always threads an explicit backend through resolveCommandOpts.
+  // The Kernel is the ONLY issue backend. An explicit `backend` is still honored so
+  // tests (and any future adapter) can inject one; the no-arg fallback builds the
+  // kernel backend, which is also what the CLI path threads in via resolveCommandOpts.
   const resolvedBackend = backend || createKernelIssueBackend();
 
   return {
@@ -531,105 +181,18 @@ function resolveLeaseTtlMs(env = {}) {
   return ttl;
 }
 
-// Graceful Beads→Kernel fallback (issue 7f09ae93). When the resolved backend is
-// Beads but Beads is NOT initialized in this project AND a Forge Kernel store
-// already exists at `<gitCommonDir>/forge/kernel.sqlite`, route the operation to
-// the kernel instead of dead-ending on "Beads is not initialized". This unblocks
-// upgraders whose repo predates the kernel default (or whose global `forge` binary
-// is stale and still resolves Beads): the kernel is the correct default and already
-// holds their issues. Returns the resolved kernel paths when the fallback applies,
-// or null to keep the Beads path (so a genuine no-store repo still gets the Beads
-// not-initialized error). Path resolution reuses buildLocalBrokerConfig so the probed
-// location matches exactly what the broker would open. Never throws.
-function resolveBeadsFallbackToKernel(projectRoot, deps = {}) {
-  const checkInit = deps.isBeadsInitialized || isBeadsInitialized;
-  if (checkInit(projectRoot)) {
-    // Beads is initialized — honor the explicit Beads selection, no fallback.
-    return null;
-  }
-
-  let config;
-  try {
-    config = buildLocalBrokerConfig({
-      projectRoot,
-      gitCommonDir: deps.gitCommonDir,
-      databasePath: deps.kernelDatabasePath,
-      execFileSync: deps.execFileSync,
-    });
-  } catch {
-    // No resolvable kernel location (e.g. projectRoot is not a git repo) — there is
-    // no safe fallback target, so let the Beads path report its own error.
-    return null;
-  }
-
-  const fileExists = deps.existsSync || existsSync;
-  if (!fileExists(config.databasePath)) {
-    // No kernel store either — preserve the Beads not-initialized error.
-    return null;
-  }
-
-  return { kernelDatabasePath: config.databasePath, gitCommonDir: config.gitCommonDir };
-}
-
 async function runIssueOperation(operation, rawArgs, projectRoot, deps = {}) {
   const injectedService = deps.createService;
-  let routeToKernel = shouldUseKernelBroker(deps);
-  let effectiveDeps = deps;
-
-  // Beads→Kernel graceful fallback (7f09ae93). Only considered when a service is not
-  // injected (an injected service owns backend selection), the selection is not
-  // already Kernel, and this is not a help invocation (help must never touch a
-  // backend). When it applies, treat the op as Kernel-routed end-to-end (backend
-  // construction AND the projection-target seam below).
-  if (!injectedService && !routeToKernel && !isHelpInvocation(rawArgs)) {
-    const fallback = resolveBeadsFallbackToKernel(projectRoot, deps);
-    if (fallback) {
-      routeToKernel = true;
-      effectiveDeps = {
-        ...deps,
-        useKernelBroker: true,
-        kernelDatabasePath: fallback.kernelDatabasePath,
-        gitCommonDir: fallback.gitCommonDir,
-      };
-      const notify = deps.warn || ((msg) => process.stderr.write(`${msg}\n`));
-      notify(
-        'Notice: Beads is not initialized, but a Forge Kernel store exists — using the '
-        + 'kernel backend (the default). Run `forge setup` to finish migrating.',
-      );
-    }
-  }
-
-  const createService = injectedService || (() => {
-    const context = {
-      projectRoot,
-      deps: effectiveDeps,
-    };
-
-    if (routeToKernel) {
-      return createIssueService({
-        backend: createKernelIssueBackend(context),
-      });
-    }
-
-    const backendDeps = {
-      isBeadsInitialized: deps.isBeadsInitialized,
-      runBdCommand: deps.runBdCommand,
-      spawn: deps.spawn,
-      platform: deps.platform,
-      env: deps.env,
-    };
 
-    return createIssueService({
-      backend: createBeadsIssueBackend(backendDeps),
-    });
-  });
+  const createService = injectedService || (() => createIssueService({
+    backend: createKernelIssueBackend({ projectRoot, deps }),
+  }));
 
   const service = createService();
   // Thread a distinct per-agent actor (and, when present, a stable session id) into the
   // mutation context so the Kernel's claim idempotency key is scoped per agent rather than
   // to the shared 'forge' default (kernel d71a824b). Undefined values are omitted so the
-  // historical default is preserved for no-env callers, and the Beads backend — which
-  // ignores context.actor/sessionId — is unaffected.
+  // historical default is preserved for no-env callers.
   const actorEnv = deps.env || process.env;
   const actor = resolveIssueActor(actorEnv);
   const sessionId = typeof actorEnv.FORGE_SESSION_ID === 'string' && actorEnv.FORGE_SESSION_ID.trim()
@@ -651,11 +214,11 @@ async function runIssueOperation(operation, rawArgs, projectRoot, deps = {}) {
     ...(leaseTtlMs ? { leaseTtlMs } : {}),
     // Kernel mutations enqueue a projection-outbox "dirty marker" that `forge export`
     // (the D16 git-JSONL portability projection) drains under target 'jsonl'. The
-    // broker's legacy primitive default is 'beads', so without steering the target
-    // here every Kernel-created issue is enqueued as 'beads' and `forge export` — which
-    // drains 'jsonl' — finds nothing, silently never emitting git-tracked JSONL. Only
-    // the Kernel path uses this seam (`context.projectionTarget`); Beads ignores it.
-    ...(routeToKernel ? { projectionTarget: 'jsonl' } : {}),
+    // broker's legacy primitive default is still 'beads', so without steering the target
+    // here every Kernel-created issue would be enqueued as 'beads' and `forge export` —
+    // which drains 'jsonl' — would find nothing, silently never emitting git-tracked
+    // JSONL. Unconditional now that the Kernel is the only backend.
+    projectionTarget: 'jsonl',
   });
 
   const queueGitHubProjection = deps.enqueueGitHubProjection || deps.queueGitHubProjection;
@@ -676,22 +239,8 @@ async function runIssueOperation(operation, rawArgs, projectRoot, deps = {}) {
 
 module.exports = {
   createIssueService,
-  createBeadsIssueBackend,
   createKernelIssueBackend,
-  runBeadsOperation,
   runIssueOperation,
-  buildBdArgs,
-  extractErrorMessage,
-  getCommandErrorMessage,
-  getSpawnOptions,
-  hasEmptyShowPayload,
-  hasBdSoftFailure,
   isHelpInvocation,
-  normalizeExecOutput,
-  runBdCommand,
-  getBdCommandCandidates,
-  getPathEntries,
   resolveIssueActor,
-  resolveBeadsFallbackToKernel,
-  resolveWindowsCommandCandidates,
 };

package/lib/gate-events.js

@@ -23,7 +23,7 @@
  * runtime graph + `.forge/config.yaml`; this module only records/reads the events.
  */
 
-const { buildMigratedKernelIssueDeps } = require('./kernel/cli-broker-factory');
+const { resolveOwnedKernel, closeIfOwned } = require('./kernel/owned-kernel');
 const { resolveIssueActor } = require('./forge-issues');
 
 const GATE_APPROVED_EVENT = 'gate.approved';
@@ -37,22 +37,12 @@ const GATE_EVENT_TYPES = {
 const ISSUE_ENTITY_TYPE = 'issue';
 const GATE_EVENT_ORIGIN = 'cli';
 
-/**
- * Resolve the kernel broker + driver + config. Tests (and the orchestrator) inject
- * a shared, already-migrated kernel via `deps`; the CLI path builds a fresh one for
- * the (short-lived) process.
- *
- * @param {string} projectRoot
- * @param {{ kernelBroker?: Object, kernelDriver?: Object }} [deps]
- * @returns {Promise<{ broker: Object, driver: Object, config: Object }>}
- */
-async function resolveGateKernel(projectRoot, deps = {}) {
-  if (deps.kernelBroker && deps.kernelDriver) {
-    return { broker: deps.kernelBroker, driver: deps.kernelDriver, config: deps.kernelBroker.config };
-  }
-  const built = await buildMigratedKernelIssueDeps({ projectRoot });
-  return { broker: built.kernelBroker, driver: built.kernelDriver, config: built.kernelBroker.config };
-}
+// Kernel lifecycle (resolve + close-what-you-built) is shared with
+// grounding/context-events via lib/kernel/owned-kernel. A gate read/append that
+// builds its own kernel must close it — an unclosed SQLite handle leaks and, on
+// Windows, locks the DB directory (EBUSY on rmSync, kernel issue e62e4bde). Safe
+// here today because gate events only fire on explicit `forge gate` commands,
+// but the leak is identical so we close proactively via closeIfOwned.
 
 /**
  * Idempotency key for a gate event. Scoped to issue + gate + actor + decision so a
@@ -110,44 +100,49 @@ async function recordGateEvent(projectRoot, params = {}) {
   }
 
   const actor = resolveIssueActor(env || process.env) || 'forge';
-  const { driver, config } = await resolveGateKernel(projectRoot, deps);
-
-  const entity = await driver.loadKernelEntity(ISSUE_ENTITY_TYPE, issueId, {}, config);
-  if (!entity) {
-    return { ok: false, issueMissing: true, actor };
-  }
+  const kernel = await resolveOwnedKernel(projectRoot, deps);
+  const { driver, config } = kernel;
 
-  const idempotencyKey = gateIdempotencyKey(eventType, issueId, gateId, actor);
+  try {
+    const entity = await driver.loadKernelEntity(ISSUE_ENTITY_TYPE, issueId, {}, config);
+    if (!entity) {
+      return { ok: false, issueMissing: true, actor };
+    }
 
-  const existing = await driver.loadKernelEventByIdempotencyKey(idempotencyKey, {}, config);
-  if (existing) {
-    return { ok: true, duplicate: true, event: parseGateEvent(existing), actor };
-  }
+    const idempotencyKey = gateIdempotencyKey(eventType, issueId, gateId, actor);
 
-  const payload = { gate: gateId, actor };
-  if (typeof reason === 'string' && reason.length > 0) payload.reason = reason;
-
-  const event = {
-    entity_type: ISSUE_ENTITY_TYPE,
-    entity_id: issueId,
-    event_type: eventType,
-    idempotency_key: idempotencyKey,
-    expected_revision: 0,
-    actor,
-    origin: GATE_EVENT_ORIGIN,
-    payload,
-    created_at: now || new Date().toISOString(),
-  };
+    const existing = await driver.loadKernelEventByIdempotencyKey(idempotencyKey, {}, config);
+    if (existing) {
+      return { ok: true, duplicate: true, event: parseGateEvent(existing), actor };
+    }
 
-  try {
-    const inserted = await driver.insertKernelEvent(event, {}, config);
-    return { ok: true, duplicate: false, event: parseGateEvent(inserted), actor };
-  } catch (error) {
-    if (isIdempotencyRace(error)) {
-      const winner = await driver.loadKernelEventByIdempotencyKey(idempotencyKey, {}, config);
-      return { ok: true, duplicate: true, event: winner ? parseGateEvent(winner) : parseGateEvent(event), actor };
+    const payload = { gate: gateId, actor };
+    if (typeof reason === 'string' && reason.length > 0) payload.reason = reason;
+
+    const event = {
+      entity_type: ISSUE_ENTITY_TYPE,
+      entity_id: issueId,
+      event_type: eventType,
+      idempotency_key: idempotencyKey,
+      expected_revision: 0,
+      actor,
+      origin: GATE_EVENT_ORIGIN,
+      payload,
+      created_at: now || new Date().toISOString(),
+    };
+
+    try {
+      const inserted = await driver.insertKernelEvent(event, {}, config);
+      return { ok: true, duplicate: false, event: parseGateEvent(inserted), actor };
+    } catch (error) {
+      if (isIdempotencyRace(error)) {
+        const winner = await driver.loadKernelEventByIdempotencyKey(idempotencyKey, {}, config);
+        return { ok: true, duplicate: true, event: winner ? parseGateEvent(winner) : parseGateEvent(event), actor };
+      }
+      throw error;
     }
-    throw error;
+  } finally {
+    closeIfOwned(kernel);
   }
 }
 
@@ -160,11 +155,15 @@ async function recordGateEvent(projectRoot, params = {}) {
  * @returns {Promise<Array<{ event_type: string, gate: string, actor: string, created_at: string, reason?: string }>>}
  */
 async function listGateEvents(projectRoot, issueId, options = {}) {
-  const { driver, config } = await resolveGateKernel(projectRoot, options.deps);
-  const rows = await driver.listKernelEvents(ISSUE_ENTITY_TYPE, issueId, {}, config);
-  return (rows || [])
-    .filter(row => typeof row.event_type === 'string' && row.event_type.startsWith('gate.'))
-    .map(parseGateEvent);
+  const kernel = await resolveOwnedKernel(projectRoot, options.deps);
+  try {
+    const rows = await kernel.driver.listKernelEvents(ISSUE_ENTITY_TYPE, issueId, {}, kernel.config);
+    return (rows || [])
+      .filter(row => typeof row.event_type === 'string' && row.event_type.startsWith('gate.'))
+      .map(parseGateEvent);
+  } finally {
+    closeIfOwned(kernel);
+  }
 }
 
 /**