@loicngr/kobo 1.7.10 → 1.7.12

package/AGENTS.md

@@ -273,6 +273,22 @@ These rules are the source of truth and are also written to `.ai/.git-convention
 
 The human user of this repository prefers French for conversational exchanges. Code, tests, commit messages, and documentation (including this file) remain in English for toolchain compatibility, but chat responses should be in French unless the user switches.
 
+## Design System
+
+Always read `DESIGN.md` (repo root) before making any visual or UI decisions. Every
+font choice, color, spacing value, and aesthetic decision is defined there. The CSS
+variables in `src/client/src/css/design-tokens.scss` are the runtime source of truth
+for the values documented in `DESIGN.md` — never hardcode hex colors or spacing
+literals in components.
+
+Aesthetic direction: **Brutally Minimal × Industrial** (Linear / Anthropic Console
+reference). Dark-native, monochrome, single indigo accent (`--kobo-accent` /
+`#6c63ff`) used rarely. No purple gradients, no decorative illustrations, no
+bubble-pill shapes, no spring physics. Geist + Geist Mono for technical values.
+
+When reviewing or writing UI code, flag any deviation from `DESIGN.md`. Do not
+deviate from the documented system without explicit user approval.
+
 ## What NOT to do
 
 - Don't drop-and-recreate the database to apply schema changes. The project is in production — every schema change ships as a migration that preserves data (see [Database migrations](#database-migrations)).
@@ -282,3 +298,4 @@ The human user of this repository prefers French for conversational exchanges. C
 - Don't break the single-source-of-truth of `CLAUDE.md` → `AGENTS.md` symlink. Edit `AGENTS.md`; `CLAUDE.md` follows automatically.
 - Don't skip `try/catch` swallowing on best-effort cleanup (agent stop, dev-server stop, worktree removal). These must never break the primary operation.
 - Don't hardcode user-visible text in the frontend. Every string must go through `$t()` / `t()` with keys in all 5 locale files. See [Internationalization (i18n)](#internationalization-i18n).
+- Don't hardcode hex colors, spacing literals, or font names in components. Use the CSS variables from `src/client/src/css/design-tokens.scss` and the patterns in `DESIGN.md`. See [Design System](#design-system).

package/dist/server/routes/notion.js

@@ -1,7 +1,18 @@
 import { Hono } from 'hono';
-import { extractNotionPage } from '../services/notion-service.js';
+import { extractNotionPage, listNotionUsers } from '../services/notion-service.js';
 /** Hono sub-router for Notion page extraction. */
 const app = new Hono();
+// GET /api/notion/users — list workspace users (humans only, for the settings dropdown)
+app.get('/users', async (c) => {
+    try {
+        const users = await listNotionUsers();
+        return c.json({ users });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/notion/extract — extract a Notion page
 app.post('/extract', async (c) => {
     try {

package/dist/server/routes/templates.js

@@ -64,6 +64,17 @@ app.patch('/:slug', async (c) => {
         return c.json({ error: message }, statusForServiceError(message));
     }
 });
+// POST /api/templates/reload-defaults — re-apply default seed without overwriting user templates
+app.post('/reload-defaults', (c) => {
+    try {
+        const result = templatesService.reloadDefaultTemplates();
+        return c.json(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // DELETE /api/templates/:slug — delete a template
 app.delete('/:slug', (c) => {
     try {

package/dist/server/routes/workspaces.js

@@ -21,6 +21,7 @@ import { getActiveReviewTemplate, renderReviewTemplate } from '../services/revie
 import * as sentryService from '../services/sentry-service.js';
 import * as settingsService from '../services/settings-service.js';
 import { runSetupScript } from '../services/setup-script-service.js';
+import { getSuitePrompts } from '../services/skill-suite-prompts.js';
 import * as terminalService from '../services/terminal-service.js';
 import * as wakeupService from '../services/wakeup-service.js';
 import * as wsService from '../services/websocket-service.js';
@@ -160,6 +161,18 @@ app.post('/', migrationGuard, async (c) => {
                 const message = err instanceof Error ? err.message : String(err);
                 return c.json({ error: `Failed to extract Notion page: ${message}` }, 422);
             }
+            const assigneeProperty = settingsService.getGlobalSettings().notionAssigneeProperty;
+            if (assigneeProperty && body.notionUrl) {
+                const notionUrl = body.notionUrl;
+                notionService
+                    .assignNotionPageToSelf(notionUrl, assigneeProperty)
+                    .then((result) => {
+                    if (!result.assigned) {
+                        console.warn(`[notion] Auto-assign skipped for ${notionUrl}: ${result.reason}`);
+                    }
+                })
+                    .catch((err) => console.error('[notion] Auto-assign threw unexpectedly:', err));
+            }
         }
         let sentryContent = null;
         if (body.sentryUrl) {
@@ -170,6 +183,17 @@ app.post('/', migrationGuard, async (c) => {
                 const message = err instanceof Error ? err.message : String(err);
                 return c.json({ error: `Failed to extract Sentry issue: ${message}` }, 422);
             }
+            if (sentryContent && sentryContent.assignee.length === 0) {
+                const sentryUrl = body.sentryUrl;
+                sentryService
+                    .assignSentryIssueToSelf(sentryUrl)
+                    .then((result) => {
+                    if (!result.assigned) {
+                        console.warn(`[sentry] Auto-assign skipped for ${sentryUrl}: ${result.reason}`);
+                    }
+                })
+                    .catch((err) => console.error('[sentry] Auto-assign threw unexpectedly:', err));
+            }
         }
         // Create workspace record
         const globalSettings = settingsService.getGlobalSettings();
@@ -608,6 +632,22 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `\n# Git conventions\nIMPORTANT: Before any git operation (commit, branch, rebase, merge, push), read and apply the conventions defined in \`.ai/.git-conventions.md\`. They are project-specific and override any default behavior. Re-read this file if you're unsure or if context was compacted.\n`;
             }
             brainstormPrompt += `\nIMPORTANT: Start by reading CLAUDE.md and/or AGENTS.md at the project root if they exist — they contain project conventions and instructions you must follow.`;
+            // Resolve the suite-specific brainstorming instruction (citing
+            // superpowers:brainstorming / writing-plans, or gstack /office-hours +
+            // /autoplan, etc.). The marker `[BRAINSTORM_COMPLETE]` stays universal —
+            // only the path to it changes per suite.
+            const globalSettings = settingsService.getGlobalSettings();
+            const suitePrompts = getSuitePrompts(globalSettings.skillSuite, {
+                brainstormingInstruction: globalSettings.customBrainstormingInstruction,
+            });
+            // gstack brain sync — load project-specific learnings (patterns, pitfalls,
+            // preferences) accumulated by /learn across prior sessions. Only when the
+            // active skill suite includes gstack, and only if the user has actually
+            // installed gstack locally (the binary may be absent — skip silently).
+            // Fast + idempotent; safe to run on every workspace boot.
+            if (globalSettings.skillSuite === 'gstack' || globalSettings.skillSuite === 'superpowers+gstack') {
+                brainstormPrompt += `\n\nIMPORTANT (gstack): Before brainstorming, check whether \`~/.claude/skills/gstack/bin/gstack-brain-sync\` exists. If it does, run it with \`--once\` to load gstack learnings (project-specific patterns, pitfalls, and preferences from prior sessions) into memory. If the binary is missing (gstack not installed in this environment), skip silently and continue — do NOT install anything and do NOT mention the absence. Fast and idempotent when present.`;
+            }
             if (body.autoLoop === true) {
                 // Auto-loop is armed — brainstorm must end with task seeding + mark-ready,
                 // NOT with implementation. The auto-loop will drive implementation after.
@@ -621,7 +661,7 @@ app.post('/', migrationGuard, async (c) => {
                 const projectSettingsForE2e = settingsService.getProjectSettings(body.projectPath);
                 const e2eSettings = projectSettingsForE2e?.e2e ?? { framework: '', skill: '', prompt: '' };
                 const finalizationSettings = projectSettingsForE2e?.finalization ?? { prompt: '' };
-                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you have a clear plan, create a plan file.
+                brainstormPrompt += `\n\n${suitePrompts.brainstormingInstruction}
 
 Auto-loop mode is active for this workspace. After the plan is ready, DO NOT implement anything. Instead:
 
@@ -632,7 +672,9 @@ When the steps above are complete, output [BRAINSTORM_COMPLETE] on its own line
 ${AUTO_LOOP_HARD_RULES}`;
             }
             else {
-                brainstormPrompt += `\n\nThen brainstorm the implementation approach. Explore the codebase to understand the existing structure. Ask clarifying questions if needed. When you're done brainstorming and have a clear plan, create a plan file and proceed with implementation. Once you have completed the brainstorming phase, output [BRAINSTORM_COMPLETE] on its own line.`;
+                brainstormPrompt += `\n\n${suitePrompts.brainstormingInstruction}
+
+Once the brainstorming + planning steps above are complete and you have a saved plan file, output [BRAINSTORM_COMPLETE] on its own line BEFORE starting implementation. Kōbō uses that marker to transition the workspace from \`brainstorming\` to \`executing\`. Then proceed with implementation.`;
             }
             try {
                 const agent = agentManager.startAgent(workspace.id, worktreePath, brainstormPrompt, workspace.model, false, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);

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

@@ -184,6 +184,8 @@ Current pending task (highest priority, non-acceptance-criterion first):
 - Title: {taskTitle}
 - Is acceptance criterion: {isAcceptanceCriterion}
 {overrideBlock}
+Throughout the steps below, keep the workspace description current via \`kobo__set_workspace_agent_description(description)\` so the user sees your state in the sidebar without opening the workspace. Update it at the start of the iteration (e.g. "Iter #{n}: implementing <short task title>") AND whenever your focus shifts (e.g. "Running tests", "Awaiting code review", "Fixing review feedback", "Marking task done"). Plain text, ≤200 chars.
+
 Your job this iteration:
 1. Read \`kobo__list_tasks\` to see all tasks and the big picture.
 2. Implement the SINGLE task above and nothing else. Do not pick a different task.

package/dist/server/services/notion-service.js

@@ -269,6 +269,119 @@ export async function extractNotionPage(notionUrl) {
         mcpProcess.kill();
     }
 }
+export async function listNotionUsers() {
+    const global = getGlobalSettings();
+    const mcpProcess = spawnNotionMcp(global.notionMcpKey);
+    try {
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => resolve(), 1000);
+            mcpProcess.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to start MCP Notion server: ${err.message}`));
+            });
+            mcpProcess.stdout?.once('data', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        await initializeMcp(mcpProcess);
+        const collected = [];
+        let startCursor;
+        for (let i = 0; i < 50; i++) {
+            const args = { page_size: 100 };
+            if (startCursor)
+                args.start_cursor = startCursor;
+            const raw = await callMcpTool(mcpProcess, 'API-get-users', args);
+            const result = unwrapMcpResult(raw);
+            if (!result || typeof result !== 'object')
+                break;
+            const page = result;
+            const results = Array.isArray(page.results) ? page.results : [];
+            for (const entry of results) {
+                if (entry.type !== 'person')
+                    continue;
+                const id = typeof entry.id === 'string' ? entry.id : '';
+                const name = typeof entry.name === 'string' ? entry.name.trim() : '';
+                const person = entry.person;
+                const email = person && typeof person.email === 'string' ? person.email : '';
+                if (!id || !email)
+                    continue;
+                const avatarUrl = typeof entry.avatar_url === 'string' && entry.avatar_url.length > 0 ? entry.avatar_url : null;
+                collected.push({ id, name: name || email, email, avatarUrl });
+            }
+            if (!page.has_more)
+                break;
+            startCursor = typeof page.next_cursor === 'string' ? page.next_cursor : undefined;
+            if (!startCursor)
+                break;
+        }
+        collected.sort((a, b) => a.name.localeCompare(b.name, 'fr'));
+        return collected;
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
+export async function assignNotionPageToSelf(notionUrl, propertyName) {
+    if (!propertyName)
+        return { assigned: false, reason: 'no property name configured' };
+    const global = getGlobalSettings();
+    const userId = global.notionUserId.trim();
+    if (!userId)
+        return { assigned: false, reason: 'no Notion user UUID configured in settings' };
+    let pageId;
+    try {
+        pageId = parseNotionUrl(notionUrl);
+    }
+    catch (err) {
+        return { assigned: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    let mcpProcess;
+    try {
+        mcpProcess = spawnNotionMcp(global.notionMcpKey);
+    }
+    catch (err) {
+        return { assigned: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => resolve(), 1000);
+            mcpProcess.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to start MCP Notion server: ${err.message}`));
+            });
+            mcpProcess.stdout?.once('data', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        await initializeMcp(mcpProcess);
+        const pageRaw = await callMcpTool(mcpProcess, 'API-retrieve-a-page', { page_id: pageId });
+        const pageResult = unwrapMcpResult(pageRaw);
+        if (pageResult && typeof pageResult === 'object') {
+            const props = pageResult.properties;
+            const prop = props?.[propertyName];
+            if (prop && Array.isArray(prop.people) && prop.people.length > 0) {
+                return { assigned: false, reason: 'property already has an assignee' };
+            }
+        }
+        await callMcpTool(mcpProcess, 'API-patch-page', {
+            page_id: pageId,
+            properties: {
+                [propertyName]: { people: [{ id: userId }] },
+            },
+        });
+        return { assigned: true, reason: `assigned ${userId} to "${propertyName}"` };
+    }
+    catch (err) {
+        return { assigned: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
 /** Update a status property on a Notion page. Best-effort, does not throw. */
 export async function updateNotionStatus(notionUrl, propertyName, statusValue) {
     const pageId = parseNotionUrl(notionUrl);

package/dist/server/services/sentry-service.js

@@ -87,6 +87,8 @@ export function parseSentryResponse(markdown, numericId) {
     const extraData = matchSection(markdown, 'Extra Data');
     const additionalContext = matchSection(markdown, 'Additional Context');
     const extraContext = [extraData, additionalContext].filter((s) => s.length > 0).join('\n\n');
+    const rawAssignee = matchField(markdown, 'Assigned To') || matchField(markdown, 'Assignee') || matchField(markdown, 'Assigned');
+    const assignee = /^(unassigned|none|-|n\/a)$/i.test(rawAssignee.trim()) ? '' : rawAssignee.trim();
     return {
         issueId,
         issueNumericId: numericId,
@@ -100,6 +102,7 @@ export function parseSentryResponse(markdown, numericId) {
         tags,
         offendingSpans: parseOffendingSpans(markdown),
         extraContext,
+        assignee,
     };
 }
 // ─── extractSentryIssue ───────────────────────────────────────────────────────
@@ -133,3 +136,66 @@ export async function extractSentryIssue(url) {
         mcpProcess.kill();
     }
 }
+function extractSentryUserId(whoamiResult) {
+    if (typeof whoamiResult === 'string') {
+        const match = whoamiResult.match(/User\s*ID(?:\s*is)?\s*[:=]?\s*(\d+)/i);
+        return match ? match[1] : null;
+    }
+    if (!whoamiResult || typeof whoamiResult !== 'object')
+        return null;
+    const r = whoamiResult;
+    if (typeof r.id === 'string' && r.id.length > 0)
+        return r.id;
+    if (typeof r.id === 'number')
+        return String(r.id);
+    for (const key of ['user', 'data', 'me']) {
+        const nested = r[key];
+        if (nested && typeof nested === 'object') {
+            const inner = nested;
+            if (typeof inner.id === 'string' && inner.id.length > 0)
+                return inner.id;
+            if (typeof inner.id === 'number')
+                return String(inner.id);
+        }
+    }
+    return null;
+}
+export async function assignSentryIssueToSelf(issueUrl) {
+    let config;
+    try {
+        const global = getGlobalSettings();
+        config = readSentryMcpConfig(global.sentryMcpKey);
+    }
+    catch (err) {
+        return { assigned: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    const mcpProcess = spawnMcpProcess(config.command, config.args, config.env);
+    try {
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => resolve(), 1000);
+            mcpProcess.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to start Sentry MCP server: ${err.message}`));
+            });
+        });
+        await initializeMcp(mcpProcess);
+        const whoamiRaw = await callMcpTool(mcpProcess, 'whoami', {});
+        const whoami = unwrapMcpResult(whoamiRaw);
+        const userId = extractSentryUserId(whoami);
+        if (!userId) {
+            return { assigned: false, reason: 'whoami did not return a user id' };
+        }
+        await callMcpTool(mcpProcess, 'update_issue', {
+            issueUrl,
+            assignedTo: `user:${userId}`,
+        });
+        return { assigned: true, reason: `assigned to user:${userId}` };
+    }
+    catch (err) {
+        return { assigned: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}

package/dist/server/services/settings-service.js

@@ -397,6 +397,36 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 23,
+        name: 'add-custom-brainstorming-instruction',
+        // Adds the 5th `custom*` field — the brainstorming-phase instruction
+        // injected into the workspace bootstrap prompt. Seeds with the agnostic
+        // baseline so users in `custom` mode can edit from a neutral start.
+        migrate: ({ global }) => {
+            if (typeof global.customBrainstormingInstruction !== 'string') {
+                global.customBrainstormingInstruction = AGNOSTIC_PROMPTS.brainstormingInstruction;
+            }
+        },
+    },
+    {
+        version: 24,
+        name: 'add-notion-assignee-property',
+        migrate: ({ global }) => {
+            if (typeof global.notionAssigneeProperty !== 'string') {
+                global.notionAssigneeProperty = '';
+            }
+        },
+    },
+    {
+        version: 25,
+        name: 'add-notion-user-id',
+        migrate: ({ global }) => {
+            if (typeof global.notionUserId !== 'string') {
+                global.notionUserId = '';
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -438,6 +468,8 @@ function defaultSettings() {
             audioNotificationVolume: 1,
             notionStatusProperty: '',
             notionInProgressStatus: '',
+            notionAssigneeProperty: '',
+            notionUserId: '',
             defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan' },
             notionMcpKey: '',
             sentryMcpKey: '',
@@ -460,6 +492,7 @@ function defaultSettings() {
             customAutoLoopReviewGate: AGNOSTIC_PROMPTS.autoLoopReviewGate,
             customAutoLoopGroomingIntro: AGNOSTIC_PROMPTS.autoLoopGroomingIntro,
             customQaPromptTemplate: AGNOSTIC_PROMPTS.qaPromptTemplate,
+            customBrainstormingInstruction: AGNOSTIC_PROMPTS.brainstormingInstruction,
         },
         projects: [],
     };
@@ -708,6 +741,8 @@ export function updateGlobalSettings(data) {
         'audioNotificationVolume',
         'notionStatusProperty',
         'notionInProgressStatus',
+        'notionAssigneeProperty',
+        'notionUserId',
         'defaultPermissionModeByEngine',
         'notionMcpKey',
         'sentryMcpKey',
@@ -730,6 +765,7 @@ export function updateGlobalSettings(data) {
         'customAutoLoopReviewGate',
         'customAutoLoopGroomingIntro',
         'customQaPromptTemplate',
+        'customBrainstormingInstruction',
     ];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     if (filtered.tags !== undefined) {

package/dist/server/services/skill-suite-prompts.js

@@ -1,4 +1,4 @@
-import { AGNOSTIC_AUTO_LOOP_GROOMING_INTRO, AGNOSTIC_AUTO_LOOP_REVIEW_GATE, AGNOSTIC_QA_PROMPT_TEMPLATE, AGNOSTIC_REVIEW_TEMPLATE, GROOMING_INTRO_GSTACK, GROOMING_INTRO_SUPERPOWERS, } from '../../shared/skill-suite-prompts.js';
+import { AGNOSTIC_AUTO_LOOP_GROOMING_INTRO, AGNOSTIC_AUTO_LOOP_REVIEW_GATE, AGNOSTIC_BRAINSTORMING_INSTRUCTION, AGNOSTIC_QA_PROMPT_TEMPLATE, AGNOSTIC_REVIEW_TEMPLATE, GROOMING_INTRO_COMBINED, GROOMING_INTRO_GSTACK, GROOMING_INTRO_SUPERPOWERS, } from '../../shared/skill-suite-prompts.js';
 // Headers and body shared with the agnostic baseline. We reconstruct them
 // locally here so the suite-specific text can sit between header and body
 // in the same shape across all 3 suites.
@@ -39,6 +39,11 @@ export const SUPERPOWERS_PROMPTS = {
     autoLoopReviewGate: 'Code review gate — BEFORE marking the task done, dispatch an independent code-reviewer subagent via the Task tool with `subagent_type: "code-reviewer"` (or `"superpowers:code-reviewer"` / `"pr-review-toolkit:code-reviewer"` — use whichever exists in this environment; fall back to `superpowers:requesting-code-review` skill if none is available). Brief the reviewer with: what you just implemented, the task title, and the commit SHA (via `git rev-parse HEAD`). Ask specifically whether the change matches the task scope, whether edge cases are handled, and whether the commit is clean.',
     autoLoopGroomingIntro: GROOMING_INTRO_SUPERPOWERS,
     qaPromptTemplate: 'QA pass for workspace "{{workspace_name}}" in project {{project_name}}.\n\nBranch: {{branch_name}}\nStaging URL: {{staging_url}}\n\nIf a QA-style skill that drives a real browser is available in this environment (e.g. via the superpowers-chrome browsing skill), use it to navigate the staging URL and exercise the changes. Otherwise, fall back to manually scripting the smoke checks and recording your findings as a bug report.',
+    brainstormingInstruction: 'Brainstorm the implementation approach with discipline:\n' +
+        '1. Use the `superpowers:brainstorming` skill — it walks you through purpose, requirements, and design BEFORE any code. Ask clarifying questions and wait for explicit user approval on the design before moving on.\n' +
+        '2. Use `superpowers:writing-plans` to turn the approved design into a multi-step implementation plan, saved under `docs/superpowers/plans/`.\n' +
+        '3. If you encounter a bug or unexpected behaviour during exploration, use `superpowers:systematic-debugging` rather than guessing.\n' +
+        "Do NOT skip the skills or rationalise around them — that's how the rigour gets lost.",
 };
 export const GSTACK_PROMPTS = {
     reviewTemplate: REVIEW_HEADER +
@@ -46,13 +51,86 @@ export const GSTACK_PROMPTS = {
         REVIEW_BODY,
     autoLoopReviewGate: 'Code review gate — BEFORE marking the task done, run /review (the gstack Staff Engineer skill). Brief it with: what you just implemented, the task title, and the commit SHA (via `git rev-parse HEAD`). Ask specifically whether the change matches the task scope, whether edge cases are handled, and whether the commit is clean. If /review auto-fixes minor issues, accept the fixes via an amend or fix-up commit, then re-run step 3 checks.',
     autoLoopGroomingIntro: GROOMING_INTRO_GSTACK,
-    qaPromptTemplate: 'QA pass for workspace "{{workspace_name}}" in project {{project_name}}.\n\nBranch: {{branch_name}}\nStaging URL: {{staging_url}}\n\nRun /qa {{staging_url}} (gstack QA Lead skill — opens a real browser, clicks through flows, finds bugs, fixes them with atomic commits, generates regression tests). If you only want a bug report without code changes, use /qa-only {{staging_url}} instead.',
+    qaPromptTemplate: `QA pass for workspace "{{workspace_name}}" in project {{project_name}}.
+
+Branch: {{branch_name}}
+Staging URL: {{staging_url}}
+
+Pick the right gstack tool for the situation:
+
+- \`/browse\` — Headless navigation: URL → interactions → screenshots. Use for quick dogfooding a flow or sanity-checking a PR.
+- \`/qa {{staging_url}}\` — Systematic QA with automatic bug fixing. Three tiers (invoke as \`/qa Quick\`, \`/qa Standard\`, or \`/qa Exhaustive\`):
+  - **Quick** — critical and high-severity bugs only.
+  - **Standard** — adds medium-severity bugs.
+  - **Exhaustive** — adds cosmetic issues.
+- \`/qa-only {{staging_url}}\` — Same methodology as \`/qa\` but report only, no code changes. Use when you only want a bug report.
+- \`/design-review\` — Visual audit (consistency, spacing, hierarchy, AI slop). Commits atomic fixes with before/after screenshots.
+
+For reproducible regression coverage that runs on every PR, prefer **Cypress** specs in \`test/cypress/\` instead of \`/qa\`. Reserve the gstack tools above for exploration, dogfooding, and one-shot visual debugging.`,
+    brainstormingInstruction: 'Brainstorm the implementation approach using the gstack sprint pipeline:\n' +
+        '1. Run `/office-hours` — six forcing questions that reframe the problem and write a design doc. This is where you challenge premises and surface alternatives before any code.\n' +
+        '2. Run `/autoplan` — it chains CEO → design → eng → DX reviews automatically (auto-detects which apply) and surfaces only the taste decisions you need to approve. Prefer this over manual orchestration.\n' +
+        '3. If you need fine control (e.g. skip a step, run one in isolation), invoke the individual skills instead: `/plan-ceo-review`, `/plan-eng-review`, `/plan-design-review`, `/plan-devex-review`.\n' +
+        '4. Wait for explicit user approval on the final plan before announcing brainstorming is done.',
 };
 export const AGNOSTIC_PROMPTS = {
     reviewTemplate: AGNOSTIC_REVIEW_TEMPLATE,
     autoLoopReviewGate: AGNOSTIC_AUTO_LOOP_REVIEW_GATE,
     autoLoopGroomingIntro: AGNOSTIC_AUTO_LOOP_GROOMING_INTRO,
     qaPromptTemplate: AGNOSTIC_QA_PROMPT_TEMPLATE,
+    brainstormingInstruction: AGNOSTIC_BRAINSTORMING_INSTRUCTION,
+};
+// ── Combined: superpowers + gstack ────────────────────────────────────────────
+// For users who install BOTH suites and want prompts that surface each suite's
+// strengths. Specialised by intent, not "use whichever is available":
+//   - /review (gstack)               → tactical code-level bug-hunting + auto-fix
+//   - superpowers:requesting-code-review → principles-level critique (silent
+//     failures, surface-area discipline, test-design soundness)
+//   - /qa, /design-review, /browse   → interactive QA (gstack only)
+//   - superpowers-chrome:browsing    → low-level browser control fallback
+export const COMBINED_PROMPTS = {
+    reviewTemplate: REVIEW_HEADER +
+        'Two complementary review skills are available — pick by intent:\n' +
+        '- `/review` (gstack Staff Engineer) for tactical bug-hunting that finds issues passing CI but blowing up in production. Auto-fixes the obvious ones.\n' +
+        '- `superpowers:requesting-code-review` for principles-level critique — silent failures, test-design soundness, surface-area discipline.\n' +
+        'You can run both on the same diff if the change is large. If neither is available, fall back to the manual checklist below.\n\n' +
+        REVIEW_BODY,
+    autoLoopReviewGate: 'Code review gate — BEFORE marking the task done, pick the appropriate review skill (two are installed):\n' +
+        '- Default to `/review` (gstack Staff Engineer) for tactical code-level bugs and auto-fixes.\n' +
+        '- Use `superpowers:requesting-code-review` instead when the task introduces tests, refactors, or design decisions worth a principles-level critique.\n\n' +
+        'Brief the chosen reviewer with: what you just implemented, the task title, and the commit SHA (via `git rev-parse HEAD`). Ask specifically whether the change matches the task scope, whether edge cases are handled, and whether the commit is clean. If the reviewer auto-fixes minor issues, accept the fixes via an amend or fix-up commit, then re-run step 3 checks.',
+    autoLoopGroomingIntro: GROOMING_INTRO_COMBINED,
+    qaPromptTemplate: `QA pass for workspace "{{workspace_name}}" in project {{project_name}}.
+
+Branch: {{branch_name}}
+Staging URL: {{staging_url}}
+
+Pick the right tool for the situation. gstack covers interactive QA; superpowers covers low-level browser control as a fallback.
+
+gstack QA toolkit (preferred for interactive QA):
+- \`/browse\` — Headless navigation: URL → interactions → screenshots. Use for quick dogfooding a flow or sanity-checking a PR.
+- \`/qa {{staging_url}}\` — Systematic QA with automatic bug fixing. Three tiers (invoke as \`/qa Quick\`, \`/qa Standard\`, or \`/qa Exhaustive\`):
+  - **Quick** — critical and high-severity bugs only.
+  - **Standard** — adds medium-severity bugs.
+  - **Exhaustive** — adds cosmetic issues.
+- \`/qa-only {{staging_url}}\` — Same methodology as \`/qa\` but report only, no code changes.
+- \`/design-review\` — Visual audit (consistency, spacing, hierarchy, AI slop). Commits atomic fixes with before/after screenshots.
+
+Superpowers alternative (low-level browser control):
+- \`superpowers-chrome:browsing\` — Direct Chrome DevTools Protocol control over an existing Chrome session: multi-tab management, form automation, content extraction. Use when you need fine-grained control beyond what \`/browse\` exposes.
+
+For reproducible regression coverage that runs on every PR, prefer **Cypress** specs in \`test/cypress/\` instead of any interactive QA skill. Reserve the tools above for exploration, dogfooding, and one-shot visual debugging.`,
+    brainstormingInstruction: 'Brainstorm using both suites — each plays to its strength:\n' +
+        '1. Early product framing: prefer gstack `/office-hours` for product-shaped work (six forcing questions + design doc). Fall back to `superpowers:brainstorming` for purely infra/refactor work where the product lens does not apply.\n' +
+        '2. Plan construction — pick whichever fits the work better:\n' +
+        '   - gstack `/autoplan` for the chained CEO/design/eng/DX pipeline (auto-detects which apply).\n' +
+        '   - `superpowers:writing-plans` for a TDD-shaped multi-step plan that maps cleanly onto subagent dispatch.\n' +
+        '3. For debugging during exploration, prefer `/investigate` (gstack — root-cause methodology) or `superpowers:systematic-debugging`, whichever you reach for first.\n' +
+        '4. Plan review gate (MANDATORY before announcing brainstorming is done): once the plan is ready, it MUST pass the gstack plan-review skills before you proceed.\n' +
+        '   - If you built the plan via `/autoplan`, you have ALREADY passed the chained reviews — skip this step.\n' +
+        '   - Otherwise (plan came from `superpowers:writing-plans` or any other path), run `/autoplan` now on the existing plan to chain the reviews, OR invoke the relevant ones individually: `/plan-ceo-review` (scope challenge), `/plan-eng-review` (architecture / edge cases / tests), `/plan-design-review` (UI / AI slop, when there is UI scope), `/plan-devex-review` (when the work has developer-facing surface).\n' +
+        '   - Apply any changes the reviews recommend before moving on.\n' +
+        '5. Wait for explicit user approval on the final reviewed plan before announcing brainstorming is done.',
 };
 /**
  * Resolve the suite prompts to use right now, given the global `skillSuite`
@@ -64,6 +142,8 @@ export function getSuitePrompts(suite, overrides) {
         return SUPERPOWERS_PROMPTS;
     if (suite === 'gstack')
         return GSTACK_PROMPTS;
+    if (suite === 'superpowers+gstack')
+        return COMBINED_PROMPTS;
     // custom mode: per-field fallback to AGNOSTIC when the override is missing/blank
     const pick = (k) => {
         const value = overrides[k];
@@ -76,5 +156,6 @@ export function getSuitePrompts(suite, overrides) {
         autoLoopReviewGate: pick('autoLoopReviewGate'),
         autoLoopGroomingIntro: pick('autoLoopGroomingIntro'),
         qaPromptTemplate: pick('qaPromptTemplate'),
+        brainstormingInstruction: pick('brainstormingInstruction'),
     };
 }