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

package/lib/core/runtime-graph.js

@@ -161,6 +161,55 @@ const PLAN_SUBSKILL_DEFINITIONS = [
 
 const PLAN_SUBSKILL_IDS = new Set(PLAN_SUBSKILL_DEFINITIONS.map(definition => definition.id));
 
+// The `smith` orchestrator composes the stage skills end-to-end. Its sub-skills
+// are the stage skill NAMES (each a real `skills/<name>/` dir), unlike plan's
+// fine-grained internal planning phases. Both resolve through the ONE generic
+// registry below (keyed by owning skill), so composition is no longer hardcoded
+// to plan. See docs/work kernel-native-skills composition epic (a0776e61) +
+// smith-orchestrator (7da81cbd).
+const SMITH_SUBSKILL_DEFINITIONS = ['plan', 'dev', 'validate', 'ship', 'review', 'verify']
+  .map(stage => ({ id: stage, label: `${stage} stage`, owner: 'smith' }));
+
+// Skills that `plan` COMPOSES at the whole-skill level (its SKILL.md `subskills:`
+// frontmatter), distinct from the fine-grained plan.* planning micro-phases in
+// PLAN_SUBSKILL_DEFINITIONS. A composed whole-skill is an advertised sub-skill
+// that must both VALIDATE and RESOLVE, but it is NOT a partialInvocation
+// micro-phase (it maps to no runtime-graph action), so it lives OUTSIDE
+// PLAN_SUBSKILL_IDS (which governs planning.template.only/skip).
+const PLAN_COMPOSED_SUBSKILLS = ['research'];
+const PLAN_COMPOSED_SUBSKILL_DEFINITIONS = PLAN_COMPOSED_SUBSKILLS.map(id => ({
+  id,
+  label: `${id.charAt(0).toUpperCase()}${id.slice(1)} (composed skill)`,
+  kind: 'composed-skill',
+  owner: 'plan',
+}));
+
+// Generic per-skill sub-skill registry, keyed by owning skill id. Generalizes
+// plan's previously hardcoded PLAN_SUBSKILL_DEFINITIONS / validatePlanSubSkillList
+// so any composing skill (plan, smith, ...) declares its sub-skill set through a
+// single mechanism. This registry is the SINGLE source for BOTH validation (ids)
+// and resolution (definitions), so getSubSkillDefinitions and validateSubSkillList
+// can never disagree. plan's set = its planning micro-phases + composed whole-skills.
+const SUBSKILL_REGISTRY = {
+  plan: [...PLAN_SUBSKILL_DEFINITIONS, ...PLAN_COMPOSED_SUBSKILL_DEFINITIONS],
+  smith: SMITH_SUBSKILL_DEFINITIONS,
+};
+
+// Validation id sets DERIVED from the registry definitions — guarantees
+// validate-vs-resolve parity for every owner (a subskill that validates also
+// resolves, and vice versa).
+const SUBSKILL_IDS_BY_OWNER = Object.fromEntries(
+  Object.entries(SUBSKILL_REGISTRY).map(([owner, defs]) => [owner, new Set(defs.map(d => d.id))])
+);
+
+function getSubSkillDefinitions(owner) {
+  return SUBSKILL_REGISTRY[owner] ? [...SUBSKILL_REGISTRY[owner]] : [];
+}
+
+function getSubSkillIds(owner) {
+  return new Set(SUBSKILL_IDS_BY_OWNER[owner] || []);
+}
+
 function planningSubSkillFromDefinition(definition) {
   return PlanningSubSkill({
     id: definition.id,
@@ -777,31 +826,51 @@ function assertStringList(value, errors, code, message) {
   return valid;
 }
 
-function validatePlanSubSkillList(value, errors, path) {
-  if (!assertStringList(
-    value,
-    errors,
-    'INVALID_PLAN_SUBSKILL_LIST',
-    `${path} must be a list of planning sub-skill IDs.`
-  )) {
+function subSkillCodesForOwner(owner) {
+  return owner === 'plan'
+    ? { listCode: 'INVALID_PLAN_SUBSKILL_LIST', unknownCode: 'UNKNOWN_PLAN_SUBSKILL', noun: 'planning sub-skill' }
+    : { listCode: 'INVALID_SUBSKILL_LIST', unknownCode: 'UNKNOWN_SUBSKILL', noun: `${owner} sub-skill` };
+}
+
+// Core list validator against an explicit known-id Set. The two callers below
+// deliberately pass DIFFERENT id sets so the two contracts never leak into each
+// other (see validatePlanSubSkillList).
+function validateAgainstKnownIds(knownIds, codes, value, errors, path) {
+  const { listCode, unknownCode, noun } = codes;
+  if (!assertStringList(value, errors, listCode, `${path} must be a list of ${noun} IDs.`)) {
     return undefined;
   }
 
   const normalized = value.map(item => item.trim());
   let hasUnknown = false;
   for (const id of normalized) {
-    if (!PLAN_SUBSKILL_IDS.has(id)) {
+    if (!knownIds.has(id)) {
       hasUnknown = true;
       errors.push({
-        code: 'UNKNOWN_PLAN_SUBSKILL',
-        message: `Unknown planning sub-skill '${id}' in ${CONFIG_SOURCE}.`,
+        code: unknownCode,
+        message: `Unknown ${noun} '${id}' in ${CONFIG_SOURCE}.`,
       });
     }
   }
-  if (hasUnknown) {
-    return undefined;
-  }
-  return normalized;
+  return hasUnknown ? undefined : normalized;
+}
+
+// Generic COMPOSITION validator, keyed by owning skill — validates a skill's
+// ADVERTISED (SKILL.md frontmatter) subskills. For `plan` the known-id set is the
+// composition union (plan.* micro-phases + composed whole-skills like research).
+function validateSubSkillList(owner, value, errors, path) {
+  const knownIds = SUBSKILL_IDS_BY_OWNER[owner] || new Set();
+  return validateAgainstKnownIds(knownIds, subSkillCodesForOwner(owner), value, errors, path);
+}
+
+// partialInvocation validator (.forge/config.yaml planning.template.only/skip).
+// SEPARATE contract from composition: it MUST accept ONLY the fine-grained plan.*
+// MICRO-PHASE ids (PLAN_SUBSKILL_IDS), never composed whole-skill ids like
+// `research` — a composed skill maps to no runtime-graph action, so `only:
+// [research]` would be silent dead config. Validates against PLAN_SUBSKILL_IDS,
+// NOT the composition union, so it fails closed on composed ids.
+function validatePlanSubSkillList(value, errors, path) {
+  return validateAgainstKnownIds(PLAN_SUBSKILL_IDS, subSkillCodesForOwner('plan'), value, errors, path);
 }
 
 function applyPlanningMode(template, nextTemplate, errors) {
@@ -968,6 +1037,11 @@ module.exports = {
   PlanningSubSkill,
   Role,
   ROLE_IDS,
+  SUBSKILL_REGISTRY,
+  getSubSkillDefinitions,
+  getSubSkillIds,
+  validateSubSkillList,
+  validatePlanSubSkillList,
   loadRuntimeGraphConfig,
   lintRuntimeGraphConfig,
   resolveRuntimeGraph,

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,
 };