claude-code-session-manager 0.47.1 → 0.48.0

package/plugins/session-manager-dev/skills/builder/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: builder
+description: Watch the current project's git history against its published npm package and drive the next publish — diff HEAD against the last release, classify + bump the version from conventional-commit prefixes, gate on typecheck/tests, publish from an isolated git worktree (never the live working directory), then report. Orchestrates 5 nested sub-skills (builder:diff, :classify-and-bump, :gate, :publish, :report). Use when the user says "/builder", "publish", "release", "cut a release", "bump the version", "ship to npm", or asks whether there's anything unpublished.
+---
+
+# builder (orchestrator)
+
+Global, project-agnostic release pipeline — works against whatever npm package the current
+project publishes (resolved via `src/main/lib/buildTarget.cjs`'s `resolveBuildTarget()`, or
+by reading `package.json` directly if that file isn't present yet). Codified from a real
+session that ran this exact sequence 4 times by hand, publishing session-manager
+v0.45.1 → v0.47.1 to npm — this skill turns that proven manual procedure into a reusable one.
+
+**Naming convention** (same as `pr-review-sweep` and `issue-address`): sub-skill directories
+are prefixed `0-`, `1-`, ... in execution order, so a plain directory listing sorts in DAG
+order without opening any file. The invocable `name:` field stays a clean colon-scoped
+identifier (`builder:diff`) without the numeric prefix.
+
+## Pipeline DAG
+
+```
+┌───────────────────────┐
+│ 0. builder:diff            │  HEAD vs. last published version (npm view, else last git tag)
+└───────────────────────┘
+      │ commit list since last release (empty → stop, nothing to do)
+      ▼
+┌───────────────────────────┐
+│ 1. builder:classify-and-bump   │  conventional-commit prefixes → patch/minor/major
+└───────────────────────────┘     (non-conventional history → ask, don't guess)
+      │ bump kind decided
+      ▼
+┌───────────────────────┐
+│ 2. builder:gate            │  npm run typecheck + npm run test:unit, both bounded
+└───────────────────────┘
+   PASS │              │ FAIL
+        ▼              ▼
+┌───────────────────────┐   STOP — report failing gate, do not publish
+│ 3. builder:publish         │  ISOLATED WORKTREE technique (see that step's own file)
+└───────────────────────┘
+      │ version bumped, tagged, pushed, published, dist-tag verified
+      ▼
+┌───────────────────────┐
+│ 4. builder:report          │  version, commits covered, dist-tag, push confirmation
+└───────────────────────┘
+```
+
+| Step | Input | Output | On failure/empty |
+|---|---|---|---|
+| 0. `builder:diff` | current project cwd | commit list since last published version (or last git tag) | no commits since last release → stop, report "nothing to publish" |
+| 1. `builder:classify-and-bump` | commit list | bump kind (`patch`/`minor`/`major`) | commits don't follow conventional-commit style → say so, ask the user rather than guessing |
+| 2. `builder:gate` | working tree at HEAD | typecheck + unit test result | either fails → stop, report the failure, do not publish |
+| 3. `builder:publish` | bump kind, gate-passed HEAD | published npm package, pushed tag + main | any step fails → stop, report which step and the worktree's state (don't leave it behind uncleaned unless it's evidence of the failure) |
+| 4. `builder:report` | publish result | one summary: version bumped, commits covered, npm dist-tag verified, git push confirmed | n/a |
+
+## Hard rules — read before running any step
+
+- **A dirty working tree in the main repo is NOT a blocker.** The isolated-worktree
+  technique in `builder:publish` sidesteps it entirely — `npm ci` + `vite build` +
+  `npm publish` all run inside a clean worktree checked out from the just-created tag, never
+  touching the live/dirty repo. Don't hold the pipeline waiting for a clean tree; that
+  guidance is superseded by this skill.
+- **Once a diff is found and the gate passes, run the full sequence through to publish
+  without pausing for reconfirmation.** This was confirmed by the user across 4 consecutive
+  manual runs in the session that originated this skill — asking "should I publish now?"
+  after the gate is green is exactly the friction this skill exists to remove.
+- **The gate is a hard stop.** A failing `typecheck` or `test:unit` run means step 3 never
+  executes — no publish, no version bump, no tag. Report the failure and stop.
+- **Never guess a version bump from unconventional commit messages.** If the commit list
+  doesn't cleanly map to `fix:`/`feat:`/`BREAKING CHANGE:` prefixes, `builder:classify-and-bump`
+  asks the user which bump to apply rather than inferring one.
+
+## Why nested skills instead of one inline sequence
+
+Each step is its own file so it shows up as its own invocation in whatever surface tracks
+skill/tool calls, and so a step can be changed (a different gate command, a new registry
+target) without touching the others — same rationale as `pr-review-sweep` and
+`issue-address`.
+
+## What this skill is not
+
+- Not a decision-maker on *whether* to release — it assumes the user (or an Epic) already
+  wants the next diff shipped. If there's genuine ambiguity about scope, `builder:classify-and-bump`
+  is the one step that pauses to ask.
+- Not a registry-agnostic tool — `builder:publish` is npm-specific (see `buildTarget.cjs`'s
+  `registry` field for future non-npm targets; out of scope for this version).
+- Not wired to any UI button — invoking this skill is the only entry point today.

package/src/main/__tests__/agentLibrary.test.cjs

@@ -0,0 +1,133 @@
+/**
+ * agentLibrary.test.cjs — unit tests for the Agent Library nav page's
+ * backend: enumerating global `~/.claude/agents/*.md` personas and
+ * detecting per-project `.claude/agents/<name>.md` overlays among
+ * currently-open tabs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/agentLibrary.test.cjs
+ */
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { listPersonas, openProjects, parseTools } = require('../agentLibrary.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkTmp(prefix) {
+  const d = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(d);
+  return d;
+}
+
+// listPersonas/openProjects take injectable deps; tests pass an identity
+// validatePath since the fixture dirs live under os.tmpdir(), not the real
+// home directory config.cjs's validatePath would otherwise enforce.
+const identityValidatePath = (p) => p;
+
+test('parseTools splits + trims a comma-separated tools frontmatter value', () => {
+  expect(parseTools('Read, Grep, Glob, Bash')).toEqual(['Read', 'Grep', 'Glob', 'Bash']);
+  expect(parseTools('')).toEqual([]);
+  expect(parseTools(undefined)).toEqual([]);
+});
+
+test('openProjects dedups by cwd and uses the last path segment as name', async () => {
+  const loadSessions = async () => ({
+    tabs: [
+      { cwd: '/home/u/Projects/alpha' },
+      { cwd: '/home/u/Projects/beta/' },
+      { cwd: '/home/u/Projects/alpha' }, // duplicate — should collapse
+      { cwd: null }, // malformed — should be skipped
+    ],
+  });
+  const projects = await openProjects({ loadSessions });
+  expect(projects).toEqual([
+    { cwd: '/home/u/Projects/alpha', name: 'alpha' },
+    { cwd: '/home/u/Projects/beta/', name: 'beta' },
+  ]);
+});
+
+test('listPersonas returns [] when the global agents dir does not exist', async () => {
+  const missingDir = path.join(os.tmpdir(), 'sm-agent-library-does-not-exist-' + Date.now());
+  const personas = await listPersonas({
+    globalDir: missingDir,
+    loadSessions: async () => ({ tabs: [] }),
+    validatePath: identityValidatePath,
+  });
+  expect(personas).toEqual([]);
+});
+
+test('listPersonas parses frontmatter and reports overridingProjects for open tabs with a local overlay', async () => {
+  const globalDir = await mkTmp('sm-agent-library-global-');
+  await fsp.writeFile(
+    path.join(globalDir, 'builder.md'),
+    [
+      '---',
+      'name: builder',
+      'description: Watch git history and drive the next publish.',
+      'tools: Read, Grep, Glob, Bash',
+      '---',
+      '',
+      'You are the Builder agent.',
+      '',
+    ].join('\n'),
+  );
+  await fsp.writeFile(
+    path.join(globalDir, 'debugger.md'),
+    ['---', 'name: debugger', 'description: Diagnose a failing test.', '---', '', 'Body.', ''].join('\n'),
+  );
+
+  const projectWithOverlay = await mkTmp('sm-agent-library-project-a-');
+  await fsp.mkdir(path.join(projectWithOverlay, '.claude', 'agents'), { recursive: true });
+  await fsp.writeFile(
+    path.join(projectWithOverlay, '.claude', 'agents', 'builder.md'),
+    '---\nname: builder\n---\nProject-specific overlay.\n',
+  );
+
+  const projectWithoutOverlay = await mkTmp('sm-agent-library-project-b-');
+
+  const loadSessions = async () => ({
+    tabs: [{ cwd: projectWithOverlay }, { cwd: projectWithoutOverlay }],
+  });
+
+  const personas = await listPersonas({ globalDir, loadSessions, validatePath: identityValidatePath });
+  expect(personas).toHaveLength(2);
+
+  const byName = Object.fromEntries(personas.map((p) => [p.name, p]));
+  expect(byName.builder.description).toBe('Watch git history and drive the next publish.');
+  expect(byName.builder.tools).toEqual(['Read', 'Grep', 'Glob', 'Bash']);
+  expect(byName.builder.body).toContain('You are the Builder agent.');
+  expect(byName.builder.overridingProjects).toEqual([path.basename(projectWithOverlay)]);
+
+  expect(byName.debugger.overridingProjects).toEqual([]);
+});
+
+test('listPersonas skips a project cwd that validatePath rejects, rather than throwing', async () => {
+  const globalDir = await mkTmp('sm-agent-library-global-');
+  await fsp.writeFile(path.join(globalDir, 'builder.md'), '---\nname: builder\n---\nBody.\n');
+
+  const rejectedProject = await mkTmp('sm-agent-library-project-rejected-');
+  await fsp.mkdir(path.join(rejectedProject, '.claude', 'agents'), { recursive: true });
+  await fsp.writeFile(path.join(rejectedProject, '.claude', 'agents', 'builder.md'), 'overlay\n');
+
+  const loadSessions = async () => ({ tabs: [{ cwd: rejectedProject }] });
+  // Simulate config.cjs's validatePath throwing for anything under the
+  // rejected project (as it would for a cwd outside the allowed-roots set)
+  // while still allowing the global agents dir itself to resolve.
+  const selectiveValidatePath = (p) => {
+    if (p.startsWith(rejectedProject)) throw new Error('outside allowed boundaries');
+    return p;
+  };
+
+  const personas = await listPersonas({ globalDir, loadSessions, validatePath: selectiveValidatePath });
+  expect(personas).toHaveLength(1);
+  expect(personas[0].overridingProjects).toEqual([]);
+});

package/src/main/agentLibrary.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+/**
+ * agentLibrary.cjs — read-only enumeration of agent personas for the
+ * "Agent Library" nav page (Home face only).
+ *
+ * Global agent definitions live at `~/.claude/agents/*.md`. Per Claude Code's
+ * own precedence rules, a project can overlay a same-named agent at
+ * `<project-cwd>/.claude/agents/<name>.md`, which wins over the global
+ * definition when both exist. This module reports, for every global agent,
+ * which of the currently-open TABs (per sessionsStore's persisted tab list —
+ * the same source of truth the renderer keeps in sync on every open/close)
+ * has such an overlay.
+ *
+ * All filesystem paths are routed through config.cjs's validatePath so this
+ * feature can't be used to read outside the home-dir boundary already
+ * enforced everywhere else in the app.
+ */
+
+const fsp = require('node:fs/promises');
+const fsSync = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { splitFrontmatter } = require('./lib/prdFrontmatter.cjs');
+const configMgr = require('./config.cjs');
+const sessionsStore = require('./sessionsStore.cjs');
+
+/** Parses the frontmatter `tools` field ("Read, Grep, Glob, Bash") into a list. */
+function parseTools(raw) {
+  if (!raw) return [];
+  return raw.split(',').map((t) => t.trim()).filter(Boolean);
+}
+
+/**
+ * Currently-open project tabs, deduped by cwd, as `{ cwd, name }` — `name`
+ * is the last path segment (matches the `projectNameFromCwd` convention used
+ * by the Scheduler's ProjectTag primitive). `loadSessions` is injectable
+ * (mirrors scheduler.cjs's notifyOriginatingTab) so tests can exercise the
+ * dedup/naming logic without touching the real persisted tabs.json.
+ */
+async function openProjects({ loadSessions = sessionsStore.load } = {}) {
+  const { tabs } = await loadSessions();
+  const seen = new Set();
+  const projects = [];
+  for (const t of tabs ?? []) {
+    if (!t || typeof t.cwd !== 'string' || !t.cwd || seen.has(t.cwd)) continue;
+    seen.add(t.cwd);
+    projects.push({ cwd: t.cwd, name: path.basename(t.cwd.replace(/\/+$/, '')) || t.cwd });
+  }
+  return projects;
+}
+
+/**
+ * Lists every global agent persona plus which open projects overlay it.
+ * Deps are injectable so tests can point `globalDir` at a fixture directory
+ * and `loadSessions` at a fake tab list without touching the real
+ * `~/.claude/agents` or `tabs.json`.
+ */
+async function listPersonas({
+  globalDir = path.join(os.homedir(), '.claude', 'agents'),
+  loadSessions = sessionsStore.load,
+  validatePath = configMgr.validatePath,
+} = {}) {
+  let files;
+  try {
+    files = (await fsp.readdir(globalDir)).filter((f) => f.endsWith('.md'));
+  } catch (e) {
+    if (e.code === 'ENOENT') return [];
+    throw e;
+  }
+
+  const projects = await openProjects({ loadSessions });
+  const personas = [];
+
+  for (const file of files.sort()) {
+    const fallbackName = file.replace(/\.md$/, '');
+    let real;
+    try {
+      real = validatePath(path.join(globalDir, file));
+    } catch {
+      continue; // out of bounds — shouldn't happen for a home-relative path
+    }
+    let text;
+    try {
+      text = await fsp.readFile(real, 'utf8');
+    } catch {
+      continue;
+    }
+    const { fm, body } = splitFrontmatter(text);
+
+    const overridingProjects = [];
+    for (const p of projects) {
+      let overlayReal;
+      try {
+        overlayReal = validatePath(path.join(p.cwd, '.claude', 'agents', file));
+      } catch {
+        continue; // project cwd outside allowed roots — skip rather than throw
+      }
+      if (fsSync.existsSync(overlayReal)) overridingProjects.push(p.name);
+    }
+
+    personas.push({
+      name: fm.name || fallbackName,
+      description: fm.description || null,
+      tools: parseTools(fm.tools),
+      path: real,
+      body: body.trim(),
+      overridingProjects,
+    });
+  }
+
+  return personas;
+}
+
+module.exports = { listPersonas, openProjects, parseTools };

package/src/main/index.cjs

@@ -30,6 +30,8 @@ const { createAdminHttp } = require('./lib/localAdminHttp.cjs');
 const prdCreate = require('./lib/prdCreate.cjs');
 const chatRunner = require('./chatRunner.cjs');
 const promptSessionEvents = require('./promptSessionEvents.cjs');
+const agentLibrary = require('./agentLibrary.cjs');
+const { resolveBuildTarget } = require('./lib/buildTarget.cjs');
 const adminHttp = createAdminHttp();
 scheduler.registerAdminRoutes(adminHttp);
 prdCreate.registerAdminRoute(adminHttp, scheduler.remote);
@@ -445,6 +447,11 @@ ipcMain.handle('app:launch-mode', () => ({
 // `claude mcp list`. Read-only, single in-flight call — no polling.
 ipcMain.handle('mcp:status', () => probeMcpStatus());
 
+// Agent Library nav page (Home face only): global `~/.claude/agents/*.md`
+// personas plus, per currently-open project tab, whether that project
+// overlays the same agent name at `<cwd>/.claude/agents/<name>.md`. Read-only.
+ipcMain.handle('agents:list-personas', () => agentLibrary.listPersonas());
+
 ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE_RULES || null);
 
 // Boot diagnostics — renderer polls these to surface toasts when `claude` isn't
@@ -681,6 +688,13 @@ ipcMain.handle('app:git-branch', validated(schemas.appGitBranch, async ({ cwd })
   });
 }));
 
+// Resolves a project's publish target for 'build'-tagged Epics — see
+// lib/buildTarget.cjs. Null means the Build toolbar button should be disabled
+// (no explicit config, no auto-discoverable publishable package.json).
+ipcMain.handle('build:resolve-target', validated(schemas.buildResolveTarget, ({ cwd }) => {
+  return resolveBuildTarget(cwd);
+}));
+
 // Containment check for the open-in-{editor,finder,terminal} handlers lives
 // in lib/insideHome.cjs — single chokepoint for the /home/bilkoEVIL prefix-trap.
 // Editor / finder / terminal logic lives in lib/openExternalApp.cjs.

package/src/main/ipcSchemas.cjs

@@ -313,7 +313,7 @@ const schedulerCreatePrd = z.object({
   originClaudeSessionId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
   // User-selected Feature/Bug tag (PRD 774) carried from the originating
   // PromptTicket — deterministic, never LLM-classified.
-  tag: z.enum(['feature', 'bug', 'discussion']).optional(),
+  tag: z.enum(['feature', 'bug', 'discussion', 'build']).optional(),
 });
 
 // Bulk archive: slug list, capped to limit unbounded retag/archive payloads.
@@ -687,6 +687,12 @@ const appGitBranch = z.object({
   cwd: z.string().min(1).max(4096),
 }).passthrough();
 
+// build:resolve-target — see src/main/lib/buildTarget.cjs. cwd is a trusted
+// TAB cwd, not validatePath'd here (same invariant as appGitBranch above).
+const buildResolveTarget = z.object({
+  cwd: z.string().min(1).max(4096),
+}).passthrough();
+
 // git:status / git:file-status — see src/main/git.cjs. cwd is validatePath'd
 // inside the handler (allowedRoots = home), so the schema only enforces shape.
 const gitStatus = z.object({
@@ -857,6 +863,7 @@ module.exports = {
     voiceSetRecording,
     appTestFireHook,
     appGitBranch,
+    buildResolveTarget,
     gitStatus,
     gitFileStatus,
     repoAnalyze,

package/src/main/lib/__tests__/buildTarget.test.cjs

@@ -0,0 +1,52 @@
+// buildTarget.cjs — resolves a project's publish destination for 'build'-tagged Epics.
+// vitest globals (test/beforeEach/afterEach) — same convention as the other .cjs tests.
+const assert = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { resolveBuildTarget } = require('../buildTarget.cjs');
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-build-target-'));
+});
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+test('explicit config file present is returned verbatim', () => {
+  const archDir = path.join(tmpDir, 'session-manager-operations', 'architecture');
+  fs.mkdirSync(archDir, { recursive: true });
+  const config = {
+    registry: 'npm',
+    packageName: 'my-pkg',
+    versionBumpPolicy: 'conventional-commits',
+    gates: ['typecheck'],
+  };
+  fs.writeFileSync(path.join(archDir, 'build-target.json'), JSON.stringify(config));
+
+  assert.deepEqual(resolveBuildTarget(tmpDir), config);
+});
+
+test('no config but package.json has name and is not private auto-discovers', () => {
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'auto-pkg' }));
+
+  assert.deepEqual(resolveBuildTarget(tmpDir), {
+    registry: 'npm',
+    packageName: 'auto-pkg',
+    versionBumpPolicy: 'conventional-commits',
+    gates: [],
+    discovered: true,
+  });
+});
+
+test('no config and package.json is private returns null', () => {
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'priv-pkg', private: true }));
+
+  assert.equal(resolveBuildTarget(tmpDir), null);
+});
+
+test('no config and no package.json returns null', () => {
+  assert.equal(resolveBuildTarget(tmpDir), null);
+});

package/src/main/lib/buildTarget.cjs

@@ -0,0 +1,56 @@
+/**
+ * buildTarget.cjs — resolves a project's publish destination for
+ * 'build'-tagged Epics.
+ *
+ * Reads `<cwd>/session-manager-operations/architecture/build-target.json`
+ * when present (a skill-authored doc, not an OWNERS-governed runtime-write
+ * namespace — see this repo's CLAUDE.md). Falls back to auto-discovery from
+ * `<cwd>/package.json` when no explicit config exists. Pure local-file read;
+ * no npm-registry network call here. `cwd` is not validated against
+ * `config.cjs`'s `validatePath` allowedRoots — callers must pass a trusted
+ * TAB cwd (the same invariant `prdLocations.cjs` relies on), not a raw
+ * renderer-supplied string.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const BUILD_TARGET_SUBPATH = ['session-manager-operations', 'architecture', 'build-target.json'];
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * resolveBuildTarget(cwd) → the project's build target config, or null if
+ * neither an explicit config nor an auto-discoverable package.json exists.
+ */
+function resolveBuildTarget(cwd) {
+  if (!cwd || typeof cwd !== 'string') return null;
+
+  const configPath = path.join(cwd, ...BUILD_TARGET_SUBPATH);
+  const explicit = readJson(configPath);
+  if (explicit && typeof explicit === 'object' && !Array.isArray(explicit) && typeof explicit.packageName === 'string') {
+    return explicit;
+  }
+
+  const pkg = readJson(path.join(cwd, 'package.json'));
+  if (pkg && typeof pkg.name === 'string' && pkg.name.length > 0 && pkg.private !== true) {
+    return {
+      registry: 'npm',
+      packageName: pkg.name,
+      versionBumpPolicy: 'conventional-commits',
+      gates: [],
+      discovered: true,
+    };
+  }
+
+  return null;
+}
+
+module.exports = { resolveBuildTarget };

package/src/preload/api.d.ts

@@ -1,3 +1,11 @@
+export interface BuildTarget {
+  registry: string;
+  packageName: string;
+  versionBumpPolicy: string;
+  gates: string[];
+  discovered?: boolean;
+}
+
 export interface ActionOutcome {
   ok: boolean;
   kind?: 'info' | 'warn' | 'error';
@@ -250,6 +258,17 @@ export interface McpStatusResult {
   checkedAt: number;
 }
 
+/** One global `~/.claude/agents/<name>.md` persona, per the Agent Library nav page. */
+export interface AgentPersona {
+  name: string;
+  description: string | null;
+  tools: string[];
+  path: string;
+  body: string;
+  /** Project names (basename of cwd) whose currently-open tab overlays this agent. */
+  overridingProjects: string[];
+}
+
 export interface VoiceHotkeyConfig {
   accelerator: string;
   mode: 'hold' | 'toggle';
@@ -1090,7 +1109,7 @@ export interface ChatCreatePrdPayload {
   /** Originating tab id — used at job completion to route a status prompt back into the tab. */
   sourceTabId?: string;
   /** User-selected Feature/Bug tag (PRD 774) carried from the originating PromptTicket. */
-  tag?: 'feature' | 'bug' | 'discussion';
+  tag?: 'feature' | 'bug' | 'discussion' | 'build';
 }
 
 export type ChatCreatePrdResult =
@@ -1170,6 +1189,8 @@ export interface SessionManagerAPI {
     engageRulesPath: () => Promise<string | null>;
     pickDirectory: () => Promise<string | null>;
     gitBranch: (cwd: string) => Promise<string | null>;
+    /** Publish target for 'build'-tagged Epics — null disables the Build toolbar button. */
+    resolveBuildTarget: (cwd: string) => Promise<BuildTarget | null>;
     rebootApp: () => void;
     testFireHook: (args: TestFireHookArgs) => Promise<TestFireHookResult>;
     /** F7 — true under SM_E2E=1; renderer uses this to suppress wizard auto-trigger. */
@@ -1284,6 +1305,9 @@ export interface SessionManagerAPI {
   mcp: {
     status: () => Promise<McpStatusResult>;
   };
+  agents: {
+    listPersonas: () => Promise<AgentPersona[]>;
+  };
   logs: {
     write: (
       scope: string,

package/src/preload/index.cjs

@@ -8,6 +8,7 @@ contextBridge.exposeInMainWorld('api', {
     engageRulesPath: () => ipcRenderer.invoke('app:engage-rules-path'),
     pickDirectory: () => ipcRenderer.invoke('app:pick-directory'),
     gitBranch: (cwd) => ipcRenderer.invoke('app:git-branch', { cwd }),
+    resolveBuildTarget: (cwd) => ipcRenderer.invoke('build:resolve-target', { cwd }),
     rebootApp: () => ipcRenderer.send('app:reboot-app'),
     archiveProject: (encoded) => ipcRenderer.invoke('app:archive-project', { encoded }),
     testFireHook: (args) => ipcRenderer.invoke('app:test-fire-hook', args),
@@ -145,6 +146,9 @@ contextBridge.exposeInMainWorld('api', {
   mcp: {
     status: () => ipcRenderer.invoke('mcp:status'),
   },
+  agents: {
+    listPersonas: () => ipcRenderer.invoke('agents:list-personas'),
+  },
   logs: {
     // ctx is optional: { cwd, tabId, epicId, tags } — when present and
     // level is 'error', main also appends a tagged line to that project's