@loicngr/kobo 1.7.2 → 1.7.3

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { nanoid } from 'nanoid';
+import * as settingsService from '../server/services/settings-service.js';
+import { slugifyProjectName } from '../server/utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../server/utils/worktree-paths.js';
 /** Allowed task status values. */
 export const VALID_TASK_STATUSES = ['pending', 'in_progress', 'done'];
@@ -164,7 +166,12 @@ export function getWorkspaceInfoHandler(db, workspaceId) {
         projectPath: row.project_path,
         sourceBranch: row.source_branch,
         workingBranch: row.working_branch,
-        worktreePath: row.worktree_path ?? resolveWorkspaceWorktreePath(row.project_path, row.working_branch),
+        worktreePath: (() => {
+            const gs = settingsService.getGlobalSettings();
+            const ps = settingsService.getProjectSettings(row.project_path);
+            const slug = gs.worktreesPrefixByProject ? slugifyProjectName(ps?.displayName ?? '', row.project_path) : undefined;
+            return (row.worktree_path ?? resolveWorkspaceWorktreePath(row.project_path, row.working_branch, gs.worktreesPath, slug));
+        })(),
         status: row.status,
         model: row.model,
         notionUrl: row.notion_url,

package/dist/server/routes/health.js

@@ -3,8 +3,9 @@ import fs from 'node:fs';
 import { Hono } from 'hono';
 import { getDb } from '../db/index.js';
 import { SCHEMA_VERSION } from '../db/migrations.js';
-import { getGlobalSettings, SETTINGS_SCHEMA_VERSION } from '../services/settings-service.js';
+import { getGlobalSettings, getProjectSettings, SETTINGS_SCHEMA_VERSION } from '../services/settings-service.js';
 import { getDbPath, getKoboHome } from '../utils/paths.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 const app = new Hono();
 function checkClaudeCli() {
@@ -47,11 +48,17 @@ app.get('/report', (c) => {
     const workspaces = db
         .prepare('SELECT id, name, project_path, working_branch, worktree_path, archived_at FROM workspaces')
         .all();
+    const healthGlobalSettings = getGlobalSettings();
     const worktreesMissing = [];
     for (const ws of workspaces) {
         if (ws.archived_at)
             continue;
-        const wtPath = ws.worktree_path ?? resolveWorkspaceWorktreePath(ws.project_path, ws.working_branch);
+        const wsProjectSettings = getProjectSettings(ws.project_path);
+        const wsProjectSlug = healthGlobalSettings.worktreesPrefixByProject
+            ? slugifyProjectName(wsProjectSettings?.displayName ?? '', ws.project_path)
+            : undefined;
+        const wtPath = ws.worktree_path ??
+            resolveWorkspaceWorktreePath(ws.project_path, ws.working_branch, healthGlobalSettings.worktreesPath, wsProjectSlug);
         if (!fs.existsSync(wtPath)) {
             worktreesMissing.push({ workspaceId: ws.id, name: ws.name, path: wtPath, exists: false });
         }
@@ -65,7 +72,6 @@ app.get('/report', (c) => {
         if (s.pid && !isProcessAlive(s.pid))
             orphaned++;
     }
-    const globalSettings = getGlobalSettings();
     const settingsRow = db.prepare('SELECT COUNT(*) as n FROM workspaces').get();
     const archivedRow = db.prepare('SELECT COUNT(*) as n FROM workspaces WHERE archived_at IS NOT NULL').get();
     const report = {
@@ -85,9 +91,9 @@ app.get('/report', (c) => {
         },
         agentSessions: { orphaned },
         integrations: {
-            notion: { configured: Boolean(globalSettings.notionMcpKey) },
-            sentry: { configured: Boolean(globalSettings.sentryMcpKey) },
-            editor: { configured: Boolean(globalSettings.editorCommand) },
+            notion: { configured: Boolean(healthGlobalSettings.notionMcpKey) },
+            sentry: { configured: Boolean(healthGlobalSettings.sentryMcpKey) },
+            editor: { configured: Boolean(healthGlobalSettings.editorCommand) },
         },
     };
     return c.json(report);

package/dist/server/routes/settings.js

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
+import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
+import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from '../services/review-template-service.js';
 import * as settingsService from '../services/settings-service.js';
+import { DEFAULT_GIT_CONVENTIONS, DEFAULT_PR_PROMPT_TEMPLATE, } from '../services/settings-service.js';
 import { listTemplates, replaceAllTemplates } from '../services/templates-service.js';
 /** Hono sub-router for global and per-project settings CRUD. */
 const app = new Hono();
@@ -25,6 +28,19 @@ app.get('/global', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/settings/defaults — expose the in-code DEFAULT_* constants for
+// global text-template settings (PR / review / git conventions / Notion /
+// Sentry initial prompts) so the UI can offer a "reset to default" button
+// without duplicating the strings on the frontend.
+app.get('/defaults', (c) => {
+    return c.json({
+        prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
+        reviewPromptTemplate: DEFAULT_REVIEW_PROMPT_TEMPLATE,
+        gitConventions: DEFAULT_GIT_CONVENTIONS,
+        notionInitialPromptTemplate: DEFAULT_NOTION_INITIAL_PROMPT,
+        sentryInitialPromptTemplate: DEFAULT_SENTRY_INITIAL_PROMPT,
+    });
+});
 // GET /api/settings/mcp-servers — list active MCP servers from Claude config
 app.get('/mcp-servers', (c) => {
     try {

package/dist/server/routes/workspaces.js

@@ -11,9 +11,11 @@ import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as autoLoopService from '../services/auto-loop-service.js';
 import * as devServerService from '../services/dev-server-service.js';
+import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, renderNotionInitialPrompt, renderSentryInitialPrompt, } from '../services/initial-prompt-template-service.js';
 import * as notionService from '../services/notion-service.js';
 import { renderPrTemplate } from '../services/pr-template-service.js';
 import { getAllPrStates } from '../services/pr-watcher-service.js';
+import { DEFAULT_REVIEW_PROMPT_TEMPLATE, renderReviewTemplate } from '../services/review-template-service.js';
 import * as sentryService from '../services/sentry-service.js';
 import * as settingsService from '../services/settings-service.js';
 import { runSetupScript } from '../services/setup-script-service.js';
@@ -23,7 +25,8 @@ import * as wsService from '../services/websocket-service.js';
 import * as workspaceService from '../services/workspace-service.js';
 import * as worktreeService from '../services/worktree-service.js';
 import * as gitOps from '../utils/git-ops.js';
-import { resolveSiblingWorkspaceWorktreePath } from '../utils/worktree-paths.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
+import { resolveSiblingWorkspaceWorktreePath, resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 /** Hono sub-router for workspace CRUD, tasks, agent lifecycle, git operations, and PR creation. */
 const app = new Hono();
 /** Tracks workspaces currently running a setup script to prevent concurrent executions. */
@@ -185,6 +188,26 @@ app.post('/', migrationGuard, async (c) => {
                 workingBranch = `${typePrefix}${ticketPrefix}--${titleSlug}`;
             }
         }
+        // Compute the project slug once and reuse it for both the prospective
+        // path check and the actual worktree creation below.
+        const projectSettings = settingsService.getProjectSettings(body.projectPath);
+        const projectSlug = globalSettings.worktreesPrefixByProject
+            ? slugifyProjectName(projectSettings?.displayName ?? '', body.projectPath)
+            : undefined;
+        // Resolve the prospective worktree path unconditionally so that:
+        //   1. We can refuse the request before any DB write when the path exists.
+        //   2. createWorkspace always receives the correct slug-prefixed path and
+        //      never falls back to the no-slug resolver inside workspace-service.
+        let prospectiveWorktreePath;
+        if (useReusedWorktree) {
+            prospectiveWorktreePath = body.worktreePath;
+        }
+        else {
+            prospectiveWorktreePath = resolveWorkspaceWorktreePath(body.projectPath, workingBranch, globalSettings.worktreesPath, projectSlug);
+            if (fs.existsSync(prospectiveWorktreePath)) {
+                return c.json({ error: `Worktree path already exists: ${prospectiveWorktreePath}` }, 409);
+            }
+        }
         let workspace = workspaceService.createWorkspace({
             name: body.name,
             projectPath: body.projectPath,
@@ -193,7 +216,8 @@ app.post('/', migrationGuard, async (c) => {
             notionUrl: body.notionUrl,
             notionPageId: body.notionPageId,
             sentryUrl: body.sentryUrl,
-            ...(useReusedWorktree ? { worktreePath: body.worktreePath, worktreeOwned: false } : {}),
+            worktreePath: prospectiveWorktreePath,
+            worktreeOwned: !useReusedWorktree,
             model: body.model,
             reasoningEffort: body.reasoningEffort,
             agentPermissionMode: resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, globalSettings),
@@ -289,7 +313,7 @@ app.post('/', migrationGuard, async (c) => {
         }
         else {
             try {
-                worktreePath = worktreeService.createWorktree(body.projectPath, workingBranch, body.sourceBranch, globalSettings.worktreesPath);
+                worktreePath = worktreeService.createWorktree(body.projectPath, workingBranch, body.sourceBranch, globalSettings.worktreesPath, projectSlug);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -484,6 +508,12 @@ app.post('/', migrationGuard, async (c) => {
         if (!setupScriptFailed) {
             // Transition to brainstorming and build the initial agent prompt
             workspaceService.updateWorkspaceStatus(workspace.id, 'brainstorming');
+            // Resolve the per-feature initial-prompt templates with single-fallback
+            // semantics: project || global is already handled inside getEffectiveSettings,
+            // and a whitespace-only string acts as a user escape hatch (skip injection).
+            // An empty string falls back to the hard-coded default below at injection time.
+            const notionTpl = effectiveSettings.notionInitialPromptTemplate || DEFAULT_NOTION_INITIAL_PROMPT;
+            const sentryTpl = effectiveSettings.sentryInitialPromptTemplate || DEFAULT_SENTRY_INITIAL_PROMPT;
             // Build prompt with tasks and acceptance criteria
             const allTasks = workspaceService.listTasks(workspace.id);
             const todos = allTasks.filter((t) => !t.isAcceptanceCriterion);
@@ -501,9 +531,18 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `\nGoal: ${notionContent.goal}\n`;
             }
             brainstormPrompt += `\nBranch: ${workingBranch}\nSource branch: ${body.sourceBranch}\nIMPORTANT: When creating a pull request, always use --base ${body.sourceBranch} to target the correct source branch.\n`;
+            brainstormPrompt += `\nWorking directory: ${worktreePath}\n`;
             if (notionFilePath) {
                 brainstormPrompt += `\nNotion ticket: ${body.notionUrl}`;
                 brainstormPrompt += `\nLocal copy: ${notionFilePath}\n`;
+                if (notionFilePath !== null && notionTpl.trim().length > 0) {
+                    const renderedNotion = renderNotionInitialPrompt(notionTpl, {
+                        ticketId: notionContent?.ticketId ?? '',
+                        notionUrl: body.notionUrl ?? '',
+                        notionFilePath,
+                    });
+                    brainstormPrompt += `\n${renderedNotion}\n`;
+                }
             }
             if (sentryFilePath && sentryContent) {
                 brainstormPrompt += `\nSentry issue: ${body.sentryUrl}`;
@@ -522,6 +561,14 @@ app.post('/', migrationGuard, async (c) => {
                         `- mcp__sentry__get_sentry_resource(url, resourceType) — fetch the issue, breadcrumbs, replay or trace\n` +
                         `- mcp__sentry__search_issue_events(organizationSlug, issueId='${sentryContent.issueId}') — recent events\n` +
                         `- mcp__sentry__get_issue_tag_values(organizationSlug, issueId='${sentryContent.issueId}', key) — filter by tag\n`;
+                if (sentryTpl.trim().length > 0) {
+                    const renderedSentry = renderSentryInitialPrompt(sentryTpl, {
+                        issueId: sentryContent.issueId,
+                        sentryUrl: body.sentryUrl ?? '',
+                        sentryFilePath,
+                    });
+                    brainstormPrompt += `\n${renderedSentry}\n`;
+                }
             }
             if (todos.length > 0) {
                 brainstormPrompt += `\nTasks:\n${todos.map((t) => `- [${t.status === 'done' ? 'x' : ' '}] ${t.title}`).join('\n')}\n`;
@@ -1559,13 +1606,24 @@ app.get('/:id/git-stats', async (c) => {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
         const worktreePath = workspace.worktreePath;
+        const freshFetch = c.req.query('freshFetch') === '1';
+        if (freshFetch) {
+            await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
+        }
+        else {
+            // Fire-and-forget: explicitly catch to avoid unhandled rejection if the
+            // helper ever changes contract and starts rejecting.
+            void gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch).catch(() => { });
+        }
         const commitCount = gitOps.getCommitCount(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const behindCount = gitOps.getCommitsBehind(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const diffStats = gitOps.getStructuredDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
         const pr = await gitOps.getPrStatusAsync(workspace.projectPath, workspace.workingBranch);
         const unpushedCount = await gitOps.getUnpushedCountAsync(worktreePath);
         const workingTree = gitOps.getWorkingTreeStatus(worktreePath);
         return c.json({
             commitCount,
+            behindCount,
             filesChanged: diffStats.filesChanged,
             insertions: diffStats.insertions,
             deletions: diffStats.deletions,
@@ -1674,6 +1732,36 @@ app.post('/:id/rollback-file', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/:id/branch-divergence?limit=50
+// Returns commits on the working branch ahead of source (`ahead`) and
+// commits on source not yet on the working branch (`behind`). One round-trip
+// for the BranchDivergenceDialog.
+app.get('/:id/branch-divergence', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const limitRaw = c.req.query('limit');
+        const parsed = parseInt(limitRaw ?? '50', 10);
+        const limit = Math.min(Math.max(1, Number.isNaN(parsed) ? 50 : parsed), 200);
+        const worktreePath = workspace.worktreePath;
+        const ahead = gitOps.listBranchCommits(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
+        const behind = gitOps.listCommitsBehind(worktreePath, workspace.sourceBranch, workspace.workingBranch, limit);
+        c.header('Cache-Control', 'no-store');
+        return c.json({
+            ahead,
+            behind,
+            sourceBranch: workspace.sourceBranch,
+            workingBranch: workspace.workingBranch,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id/commits?limit=50 — list commits between sourceBranch
 // and HEAD, each tagged with whether it's already pushed to origin/<branch>.
 app.get('/:id/commits', (c) => {
@@ -1727,6 +1815,10 @@ app.post('/:id/rename-branch', async (c) => {
         // Sibling rename: keep the same worktrees-root, swap the branch leaf.
         // Cannot use `path.dirname` directly because branches with slashes
         // (e.g. `feature/x`) make the dirname end one level too deep.
+        // Note: we don't pass a `projectSlug` argument here on purpose — the
+        // sibling resolver auto-detects whether the existing path was prefixed
+        // by inspecting its suffix, so prefixed and legacy worktrees both keep
+        // their layout across rename without us having to know the slug here.
         const newWorktreePath = resolveSiblingWorkspaceWorktreePath(workspace.projectPath, oldWorktreePath, workspace.workingBranch, newName);
         // Reject early if the target name is already in use — either as a local
         // branch or on origin. Avoids git's generic "already exists" error and
@@ -1797,6 +1889,9 @@ app.post('/:id/resync-branch', (c) => {
         // if the move fails (dir already moved, lockfile, dirty tree), we still
         // update the DB so git ops stay aligned with the current ref name — the
         // user can repair the dir manually.
+        // Same auto-detection rationale as the rename path above: the resolver
+        // recovers the (possibly slug-prefixed) root from the existing path, so
+        // we don't pass `projectSlug` here either.
         const newWorktreePath = resolveSiblingWorkspaceWorktreePath(workspace.projectPath, worktreePath, workspace.workingBranch, actual);
         try {
             gitOps.moveWorktree(workspace.projectPath, worktreePath, newWorktreePath);
@@ -2138,6 +2233,114 @@ app.post('/:id/open-pr', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/start-review — ask the agent to review committed + uncommitted changes
+app.post('/:id/start-review', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        const body = await c.req
+            .json()
+            .catch(() => ({}));
+        const additionalInstructions = (body.additionalInstructions ?? '').trim();
+        const newSession = body.newSession === true;
+        const worktreePath = workspace.worktreePath;
+        // Best-effort fetch so the base ref is fresh
+        try {
+            await execFileAsync('git', ['fetch', 'origin', workspace.sourceBranch], { cwd: worktreePath });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[start-review] git fetch origin ${workspace.sourceBranch} failed: ${msg}`);
+        }
+        // Resolve base commit
+        let baseCommit;
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', `origin/${workspace.sourceBranch}`], {
+                cwd: worktreePath,
+            });
+            baseCommit = stdout.trim();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return c.json({ error: `Cannot resolve base commit for branch ${workspace.sourceBranch}: ${msg}` }, 500);
+        }
+        // Build context
+        const commits = gitOps.getCommitsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const committedStats = gitOps.getDiffStatsBetween(worktreePath, workspace.sourceBranch, workspace.workingBranch);
+        const workingTreeStats = gitOps.getWorkingTreeDiffStats(worktreePath);
+        const diffStats = workingTreeStats.trim().length > 0
+            ? `${committedStats}\n\n— Working tree (uncommitted) —\n${workingTreeStats}`
+            : committedStats;
+        const effective = settingsService.getEffectiveSettings(workspace.projectPath);
+        const template = effective.reviewPromptTemplate || DEFAULT_REVIEW_PROMPT_TEMPLATE;
+        const rendered = renderReviewTemplate(template, {
+            workspace,
+            commits,
+            diffStats,
+            baseCommit,
+            additionalInstructions,
+        });
+        try {
+            wakeupService.cancel(workspace.id, 'user-message');
+        }
+        catch {
+            /* swallow */
+        }
+        let messageSent = false;
+        let emitSessionId;
+        if (newSession) {
+            // Stop current agent (best-effort) then start fresh.
+            try {
+                agentManager.stopAgent(workspace.id);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[start-review] stopAgent failed (continuing): ${msg}`);
+            }
+            try {
+                const agent = agentManager.startAgent(workspace.id, worktreePath, rendered, workspace.model, false /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                emitSessionId = agent?.agentSessionId;
+                messageSent = true;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return c.json({ error: `Failed to start review session: ${msg}` }, 500);
+            }
+        }
+        else {
+            const session = workspaceService.getActiveSession(workspace.id);
+            emitSessionId = session?.id;
+            try {
+                agentManager.sendMessage(workspace.id, rendered);
+                messageSent = true;
+            }
+            catch {
+                try {
+                    const agent = agentManager.startAgent(workspace.id, worktreePath, rendered, workspace.model, true /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+                    workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+                    emitSessionId = agent?.agentSessionId ?? emitSessionId;
+                    messageSent = true;
+                }
+                catch (resumeErr) {
+                    const msg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
+                    return c.json({ error: `Failed to dispatch review prompt: ${msg}` }, 500);
+                }
+            }
+        }
+        // Emit AFTER dispatch so the user:message lands in the correct session id —
+        // for newSession=true that's the freshly created session, not the previous one.
+        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, emitSessionId);
+        return c.json({ ok: true, messageSent, newSession });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 /** POST /api/workspaces/:id/mark-read — mark workspace as read (clear unread indicator). */
 app.post('/:id/mark-read', (c) => {
     try {

package/dist/server/services/agent/orchestrator.js

@@ -300,6 +300,9 @@ function readEffectiveSettingsSafe(projectPath) {
             model: 'claude-opus-4-7',
             dangerouslySkipPermissions: true,
             prPromptTemplate: '',
+            reviewPromptTemplate: '',
+            notionInitialPromptTemplate: '',
+            sentryInitialPromptTemplate: '',
             gitConventions: '',
             sourceBranch: 'main',
             devServer: null,

package/dist/server/services/auto-loop-service.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { buildE2eIterationBlock, buildFinalizationIterationBlock } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
 import * as settingsService from './settings-service.js';
@@ -252,7 +253,12 @@ function spawnNextIteration(workspaceId, opts = {}) {
         .replaceAll('{taskTitle}', task.title)
         .replaceAll('{isAcceptanceCriterion}', String(task.isAcceptanceCriterion))
         .replaceAll('{overrideBlock}', overrideBlock);
-    const worktreePath = row.worktree_path ?? resolveWorkspaceWorktreePath(row.project_path, row.working_branch);
+    const globalSettings = settingsService.getGlobalSettings();
+    const projectSlug = globalSettings.worktreesPrefixByProject
+        ? slugifyProjectName(projectSettings?.displayName ?? '', row.project_path)
+        : undefined;
+    const worktreePath = row.worktree_path ??
+        resolveWorkspaceWorktreePath(row.project_path, row.working_branch, globalSettings.worktreesPath, projectSlug);
     // Plan mode would deadlock the loop (blocks MCP + edits) — promote to bypass.
     // Other modes (bypass/strict/interactive) are honored.
     const stored = (row.agent_permission_mode ?? 'bypass');

package/dist/server/services/initial-prompt-template-service.js

@@ -0,0 +1,48 @@
+export const DEFAULT_NOTION_INITIAL_PROMPT = `MANDATORY context-enrichment for Notion ticket {ticket_id}. Run this BEFORE any codebase exploration, sub-agent dispatch, brainstorming skill, or ExitPlanMode call.
+
+1. Read {notion_file_path}.
+2. Fetch every linked Notion resource via the Notion MCP tools: sub-tickets, references, linked blocks, linked databases. Recurse one level into anything that looks task-relevant.
+3. Persist EVERYTHING you found to {notion_file_path}. Inline the sub-page content, extracted requirements, acceptance criteria, dependencies, key field values. The file becomes the single source of truth — anything not written there is invisible to the downstream agent.
+   - If Edit/Write is available right now: use it immediately on {notion_file_path}, then move on.
+   - If you are in plan mode and Edit/Write is blocked: the very FIRST line of your implementation plan MUST be a verbatim Edit/Write call on {notion_file_path} with the full enriched content. Not a paraphrase, not a TODO — the literal tool call with the file path and the new content. Place it BEFORE any code change in the plan.
+4. After the file is written (or after ExitPlanMode if you were in plan mode), re-read {notion_file_path} to confirm.
+
+HARD RULES:
+- Do NOT call ExitPlanMode until step 2 has fetched the linked resources and you know what content step 3 will write.
+- Do NOT skip step 3. "I have the context in mind" is NOT acceptable — write it to disk.
+- Do NOT dispatch sub-agents to explore the codebase before {notion_file_path} is enriched (or planned to be enriched as line 1 of your plan).`;
+export const DEFAULT_SENTRY_INITIAL_PROMPT = `MANDATORY context-enrichment for Sentry issue {issue_id}. Run this BEFORE locating the bug, writing tests, or implementing the fix.
+
+1. Read {sentry_file_path}.
+2. Use the Sentry MCP tools to fetch the latest events, breadcrumbs, tags, runtime/environment details, related issues and any reproduction hints.
+3. Persist EVERYTHING you found to {sentry_file_path}. Inline stack frames, frequent breadcrumb sequences, environment matrix, related events, hypotheses. The file becomes the single source of truth — anything not written there is invisible to the downstream fix.
+   - If Edit/Write is available right now: use it immediately on {sentry_file_path}.
+   - If you are in plan mode and Edit/Write is blocked: the very FIRST line of your implementation plan MUST be a verbatim Edit/Write call on {sentry_file_path} with the full enriched content. Not a paraphrase, not a TODO — the literal tool call with the file path and the new content. Place it BEFORE any code change in the plan.
+4. After the file is written, re-read {sentry_file_path} to confirm.
+
+HARD RULES:
+- Do NOT skip step 3. "I have the context in mind" is NOT acceptable — write it to disk.
+- Do NOT explore the codebase or write a failing test before {sentry_file_path} is enriched (or planned to be enriched as line 1 of your plan).`;
+function renderSimple(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (match, name) => {
+        if (Object.hasOwn(vars, name))
+            return vars[name];
+        return match;
+    });
+}
+/** Render the Notion initial prompt by substituting {var} placeholders. Pure. */
+export function renderNotionInitialPrompt(template, ctx) {
+    return renderSimple(template, {
+        ticket_id: ctx.ticketId,
+        notion_url: ctx.notionUrl,
+        notion_file_path: ctx.notionFilePath,
+    });
+}
+/** Render the Sentry initial prompt by substituting {var} placeholders. Pure. */
+export function renderSentryInitialPrompt(template, ctx) {
+    return renderSimple(template, {
+        issue_id: ctx.issueId,
+        sentry_url: ctx.sentryUrl,
+        sentry_file_path: ctx.sentryFilePath,
+    });
+}

package/dist/server/services/review-template-service.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+export const DEFAULT_REVIEW_PROMPT_TEMPLATE = `You are reviewing code changes on workspace "{{workspace_name}}" in project {{project_name}}.
+
+Branch: {{branch_name}}  (base: {{source_branch}})
+Base commit: {{base_commit}}
+
+If a code-review skill is available (e.g. superpowers:requesting-code-review), invoke it to drive this review. Otherwise follow the steps below directly.
+
+## Scope
+
+Review ALL changes — both committed and uncommitted in the working tree:
+- \`git diff {{base_commit}}..HEAD\` — committed changes on this branch
+- \`git status\` and \`git diff\` — uncommitted changes (staged + unstaged)
+
+## Diff summary
+{{diff_stats}}
+
+## Commits
+{{commits}}
+
+## Additional instructions
+{{additional_instructions}}
+
+## Output
+
+If no review skill is available, structure your reply as:
+1. Summary — what changed and why
+2. Issues — bugs, regressions, security or perf concerns (with file:line)
+3. Suggestions — refactor / improvement opportunities
+4. Tests — coverage gaps
+5. Verdict — ship / fix-then-ship / blocked
+`;
+function buildVariableMap(ctx) {
+    return {
+        project_name: path.basename(ctx.workspace.projectPath),
+        workspace_name: ctx.workspace.name,
+        branch_name: ctx.workspace.workingBranch,
+        source_branch: ctx.workspace.sourceBranch,
+        base_commit: ctx.baseCommit,
+        commits: ctx.commits,
+        diff_stats: ctx.diffStats,
+        notion_url: ctx.workspace.notionUrl ?? '',
+        additional_instructions: ctx.additionalInstructions.length > 0 ? ctx.additionalInstructions : '(none)',
+    };
+}
+/**
+ * Render a review prompt template by substituting {{variable}} placeholders.
+ * Pure: no I/O, no side effects. Unknown variables are left intact.
+ */
+export function renderReviewTemplate(template, ctx) {
+    const vars = buildVariableMap(ctx);
+    return template.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+        if (Object.hasOwn(vars, name)) {
+            return vars[name];
+        }
+        return match;
+    });
+}