@loicngr/kobo 1.7.34 → 1.8.1

package/dist/server/routes/changelog.js

@@ -12,7 +12,7 @@ export function parseChangelog(markdown) {
     const entries = [];
     let current = null;
     for (const line of markdown.split('\n')) {
-        const heading = line.match(/^##\s+v?(\d+\.\d+\.\d+[\w.-]*)\s*$/);
+        const heading = line.match(/^##\s+v?(\d+\.\d+\.\d+[\w./-]*)\s*$/);
         if (heading) {
             if (current)
                 entries.push({ version: current.version, notes: current.lines.join('\n').trim() });

package/dist/server/routes/settings.js

@@ -1,5 +1,7 @@
 import { Hono } from 'hono';
+import { getBackendPort } from '../services/agent/orchestrator.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
+import { generateToken, getLanUrls } from '../services/network-access-service.js';
 import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from '../services/review-template-service.js';
 import { DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT } from '../services/settings-defaults.js';
 import * as settingsService from '../services/settings-service.js';
@@ -45,6 +47,53 @@ app.get('/defaults', (c) => {
         changeSourceBranchScript: DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT,
     });
 });
+// GET /api/settings/network — network access state + LAN URLs
+app.get('/network', (c) => {
+    try {
+        const global = settingsService.getGlobalSettings();
+        return c.json({
+            enabled: global.networkAccessEnabled,
+            token: global.networkAccessToken,
+            urls: getLanUrls(getBackendPort()),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// GET /api/settings/network/ping — token validation probe (behind the gate)
+app.get('/network/ping', (c) => c.json({ ok: true }));
+// POST /api/settings/network — toggle enabled / regenerate token
+app.post('/network', async (c) => {
+    try {
+        const body = await c.req.json();
+        const current = settingsService.getGlobalSettings();
+        const patch = {};
+        let restartRequired = false;
+        if (typeof body.enabled === 'boolean' && body.enabled !== current.networkAccessEnabled) {
+            patch.networkAccessEnabled = body.enabled;
+            restartRequired = true;
+            if (body.enabled && !current.networkAccessToken) {
+                patch.networkAccessToken = generateToken();
+            }
+        }
+        if (body.regenerate) {
+            patch.networkAccessToken = generateToken();
+        }
+        const updated = settingsService.updateNetworkAccessSettings(patch);
+        return c.json({
+            enabled: updated.networkAccessEnabled,
+            token: updated.networkAccessToken,
+            urls: getLanUrls(getBackendPort()),
+            restartRequired,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/settings/mcp-servers — list active MCP servers from Claude config
 app.get('/mcp-servers', (c) => {
     try {

package/dist/server/routes/workspaces.js

@@ -1124,8 +1124,9 @@ app.delete('/:id/quota-backoff', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// POST /api/workspaces/:id/pending-wakeup — agent-initiated schedule via the
-// `kobo__schedule_wakeup` MCP tool. Replaces any existing pending wakeup.
+// POST /api/workspaces/:id/pending-wakeup — schedule a wakeup, either from
+// the `kobo__schedule_wakeup` MCP tool (agent, mode='resume') or from the UI
+// (manual, mode='fresh', default). Replaces any existing pending wakeup.
 app.post('/:id/pending-wakeup', async (c) => {
     try {
         const id = c.req.param('id');
@@ -1133,6 +1134,7 @@ app.post('/:id/pending-wakeup', async (c) => {
         const delaySeconds = body.delaySeconds;
         const prompt = body.prompt;
         const reason = body.reason;
+        const rawMode = typeof body.mode === 'string' ? body.mode : 'fresh';
         if (typeof delaySeconds !== 'number' || !Number.isFinite(delaySeconds) || delaySeconds <= 0) {
             return c.json({ error: 'delaySeconds must be a positive number' }, 400);
         }
@@ -1142,14 +1144,14 @@ app.post('/:id/pending-wakeup', async (c) => {
         if (reason !== undefined && typeof reason !== 'string') {
             return c.json({ error: 'reason must be a string when provided' }, 400);
         }
-        // Pin the wakeup to the session that scheduled it, so the resume targets
-        // that conversation instead of whichever session happens to be the latest
-        // at fire time. The MCP tool is invoked from inside an active session, so
-        // a missing controller signals misuse — reject explicitly.
-        const agentSessionId = agentManager.getActiveSessionId(id);
-        if (!agentSessionId) {
-            return c.json({ error: 'no active agent session for this workspace' }, 409);
+        if (rawMode !== 'fresh' && rawMode !== 'resume') {
+            return c.json({ error: "mode must be 'fresh' or 'resume'" }, 400);
         }
+        // 'resume' pins the active session so the wakeup resumes that conversation;
+        // 'fresh' (default) — or 'resume' with no active session — leaves it unpinned
+        // so the wakeup fires a brand-new session running `prompt`. This is what makes
+        // manual scheduling on an idle workspace possible (no more hard 409).
+        const agentSessionId = rawMode === 'resume' ? (agentManager.getActiveSessionId(id) ?? undefined) : undefined;
         wakeupService.schedule(id, delaySeconds, prompt, reason, agentSessionId);
         const pending = wakeupService.getPending(id);
         return c.json({ ok: true, pending });
@@ -2658,6 +2660,23 @@ app.post('/:id/push', async (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// POST /api/workspaces/:id/fetch — git fetch the workspace repo (all branches of origin).
+// Read-only: updates remote-tracking refs, never touches the working tree.
+app.post('/:id/fetch', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace) {
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        }
+        gitOps.fetchAllBranches(workspace.worktreePath);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/:id/pull — pull working branch from origin (fast-forward only)
 app.post('/:id/pull', (c) => {
     try {

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -5,6 +5,7 @@ import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from '.
 import { buildClaudeOptions } from './options-builder.js';
 import { buildCompactionSessionStartOutput } from './precompact-hook.js';
 import { resolveClaudeBinaryPath } from './resolve-binary.js';
+import { buildStopHookOutput } from './stop-hook.js';
 /**
  * Grace window between the SDK's terminal `result` message and the generator
  * reaching `done`. A healthy run closes within milliseconds; if the generator
@@ -89,6 +90,19 @@ export function createClaudeCodeEngine() {
                         ],
                     },
                 ],
+                // Decision-point enforcement of the "schedule a wakeup or the session
+                // stalls" invariant: when the agent tries to end its turn with
+                // background work still in flight and nothing scheduled to resume the
+                // session, inject a reminder so it calls `kobo__schedule_wakeup` instead
+                // of going idle. A passive system-prompt rule isn't enough — see
+                // stop-hook.ts. `additionalContext` continues the turn so the model acts.
+                Stop: [
+                    {
+                        hooks: [
+                            async (input) => buildStopHookOutput(options.workspaceId, input),
+                        ],
+                    },
+                ],
             };
             const { options: sdkOptions, effectivePrompt } = buildClaudeOptions({
                 prompt: options.prompt,
@@ -167,10 +181,29 @@ export function createClaudeCodeEngine() {
                     console.warn(`[claude-engine] SDK generator still open ${RESULT_DRAIN_TIMEOUT_MS}ms after 'result' — forcing session:ended`);
                     const reason = userInterrupted ? 'killed' : mapperState.sawErrorResult ? 'error' : 'completed';
                     emitSessionEnded(reason, reason === 'completed' ? 0 : null);
-                    // Best-effort: unstick the SDK so its subprocesses / MCP children
-                    // tear down. The session is reported ended regardless of whether
-                    // the abort actually propagates through the parked generator.
-                    abortController.abort();
+                    // Normally we abort here to unstick the SDK so its subprocesses / MCP
+                    // children tear down. BUT if a wakeup is scheduled for this workspace,
+                    // the agent intentionally left background work running for the wakeup
+                    // to resume and check — aborting would kill that work. Skip the abort
+                    // in that case so the background tasks survive. `session:ended` was
+                    // already emitted (so the orchestrator/auto-loop proceed and the
+                    // controller is removed, letting the wakeup fire later); the parked
+                    // generator drains on its own once the background work finishes.
+                    //
+                    // The wakeup check is a dynamic import: a static `import` of
+                    // wakeup-service here would form an engine → wakeup-service →
+                    // orchestrator → engine cycle that breaks module init under the test
+                    // SSR transform. Resolving it at call-time (once, 15s after result)
+                    // sidesteps the cycle with no hot-path cost.
+                    void (async () => {
+                        const { isWakeupScheduled } = await import('../../../wakeup-service.js');
+                        if (isWakeupScheduled(options.workspaceId)) {
+                            console.warn(`[claude-engine] generator still open ${RESULT_DRAIN_TIMEOUT_MS}ms after 'result' but a wakeup is scheduled for ${options.workspaceId} — leaving background work alive (no abort)`);
+                        }
+                        else {
+                            abortController.abort();
+                        }
+                    })();
                 }, RESULT_DRAIN_TIMEOUT_MS);
                 resultDrainTimer.unref?.();
             };

package/dist/server/services/agent/engines/claude-code/stop-hook.js

@@ -0,0 +1,56 @@
+import { isWakeupScheduled } from '../../../wakeup-service.js';
+/**
+ * Decide whether to nudge the agent to schedule a wakeup before it ends its
+ * turn. The agent should be reminded ONLY when it leaves background work
+ * in-flight with nothing scheduled to resume the session — otherwise the Kōbō
+ * session goes idle and the work stalls.
+ *
+ * Returns false (clean stop, no nudge) when:
+ *  - the stop hook is already active (anti-loop — we nudged on the prior stop);
+ *  - there is no in-flight background work (a genuine end of turn);
+ *  - an SDK-level cron/wakeup is scheduled (`session_crons`); or
+ *  - a Kōbō-level wakeup is scheduled (`pending_wakeups`).
+ */
+export function shouldNudgeWakeup(input) {
+    if (input.stopHookActive)
+        return false;
+    if (input.backgroundTaskCount <= 0)
+        return false;
+    if (input.sdkScheduledWakeupCount > 0)
+        return false;
+    if (input.koboWakeupScheduled)
+        return false;
+    return true;
+}
+/** The decision-point reminder injected when {@link shouldNudgeWakeup} is true. */
+export function buildNudgeText(backgroundTaskCount) {
+    return [
+        `⚠️ [Kōbō] You are about to end your turn with ${backgroundTaskCount} background task(s) still running, but NO wakeup is scheduled.`,
+        'This Kōbō session will go idle and will NOT resume itself — the background work will stall and never be checked.',
+        '',
+        'Before ending your turn, do ONE of:',
+        '• If you need that work to finish: call `kobo__schedule_wakeup` now with `delaySeconds` ≈ the expected remaining duration and a `prompt` telling future-you exactly what to check (log path + next step). Then end the turn.',
+        '• If the background work is no longer needed: stop it (kill the process), then end the turn.',
+        '',
+        'Do not end the turn passively waiting — nothing will wake the session.',
+    ].join('\n');
+}
+/**
+ * Build the Stop hook output for a workspace: cross-checks the SDK signals with
+ * Kōbō's own `pending_wakeups` table (since `kobo__schedule_wakeup` is an MCP
+ * tool that never appears in the SDK's `session_crons`) and returns the wakeup
+ * nudge only when the agent is genuinely about to stall.
+ */
+export function buildStopHookOutput(workspaceId, input) {
+    const backgroundTaskCount = input.background_tasks?.length ?? 0;
+    const koboWakeupScheduled = isWakeupScheduled(workspaceId);
+    const nudge = shouldNudgeWakeup({
+        stopHookActive: input.stop_hook_active ?? false,
+        backgroundTaskCount,
+        sdkScheduledWakeupCount: input.session_crons?.length ?? 0,
+        koboWakeupScheduled,
+    });
+    if (!nudge)
+        return {};
+    return { hookSpecificOutput: { hookEventName: 'Stop', additionalContext: buildNudgeText(backgroundTaskCount) } };
+}

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

@@ -22,6 +22,10 @@ let backendPort = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 300
 export function setBackendPort(port) {
     backendPort = port;
 }
+/** Current bound port of the running backend. */
+export function getBackendPort() {
+    return backendPort;
+}
 /** workspaceId -> SessionController */
 const controllers = new Map();
 /** workspaceId -> last engine session ID (for resume) */

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

@@ -72,15 +72,21 @@ function nextAfter(expression, from) {
 }
 /**
  * Validate the expression, persist the row, arm a setTimeout for the next
- * fire, emit `cron:created`. Throws on invalid expression OR when the next
- * fire is < MIN_DELAY_BETWEEN_FIRES_SECONDS seconds in the future.
+ * fire, emit `cron:created`. Throws on an invalid expression. If the first
+ * occurrence falls within MIN_DELAY_BETWEEN_FIRES_SECONDS of now, that imminent
+ * fire is SKIPPED (scheduled to the following occurrence) rather than rejected
+ * — so a valid recurring cron created near a boundary (e.g. a 15-min cron made
+ * 30s before the tick, or a daily cron made shortly before its time) still
+ * arms, and never fires within a minute of creation.
  */
 export function arm(workspaceId, args) {
     const now = new Date();
-    const next = nextAfter(args.expression, now);
-    const deltaMs = next.getTime() - now.getTime();
-    if (deltaMs < MIN_DELAY_BETWEEN_FIRES_SECONDS * 1000) {
-        throw new Error(`Cron expression resolves too close to now (minimum ${MIN_DELAY_BETWEEN_FIRES_SECONDS}s); use a longer interval`);
+    let next = nextAfter(args.expression, now);
+    if (next.getTime() - now.getTime() < MIN_DELAY_BETWEEN_FIRES_SECONDS * 1000) {
+        // Skip the imminent occurrence. The one after is guaranteed ≥60s out for
+        // any standard 5-field cron (min granularity is 1 minute), so a single skip
+        // always suffices.
+        next = nextAfter(args.expression, next);
     }
     const id = nanoid();
     const db = getDb();

package/dist/server/services/network-access-service.js

@@ -0,0 +1,67 @@
+import crypto from 'node:crypto';
+import os from 'node:os';
+const LOOPBACK_ADDRESSES = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+/** True for loopback remote addresses. Undefined → false (deny-safe). */
+export function isLoopbackAddress(address) {
+    if (!address)
+        return false;
+    return LOOPBACK_ADDRESSES.has(address);
+}
+/** Bind host for `serve()`: localhost-only when disabled, all interfaces when enabled. */
+export function resolveBindHost(enabled) {
+    return enabled ? undefined : '127.0.0.1';
+}
+/** Non-internal IPv4 URLs for the running server, for display + QR. */
+export function getLanUrls(port) {
+    const urls = [];
+    for (const infos of Object.values(os.networkInterfaces())) {
+        if (!infos)
+            continue;
+        for (const info of infos) {
+            if (info.family === 'IPv4' && !info.internal) {
+                urls.push(`http://${info.address}:${port}`);
+            }
+        }
+    }
+    return urls;
+}
+/** ~32-char url-safe random token. */
+export function generateToken() {
+    return crypto.randomBytes(24).toString('base64url');
+}
+/** Constant-time token comparison; false on empty/length mismatch (never throws). */
+export function tokenMatches(provided, expected) {
+    if (!provided || !expected)
+        return false;
+    const a = Buffer.from(provided);
+    const b = Buffer.from(expected);
+    if (a.length !== b.length)
+        return false;
+    return crypto.timingSafeEqual(a, b);
+}
+/** Core gate decision shared by the HTTP middleware and the WS upgrade guard. */
+export function evaluateNetworkAccess(params) {
+    if (isLoopbackAddress(params.address))
+        return { allow: true, status: 200 };
+    if (!params.enabled)
+        return { allow: false, status: 403 };
+    if (tokenMatches(params.providedToken, params.expectedToken))
+        return { allow: true, status: 200 };
+    return { allow: false, status: 401 };
+}
+/** WS upgrade authorization: parses `?token=` from the raw URL. */
+export function authorizeWsUpgrade(params) {
+    let providedToken;
+    try {
+        providedToken = new URL(params.rawUrl ?? '/', 'http://localhost').searchParams.get('token') ?? undefined;
+    }
+    catch {
+        providedToken = undefined;
+    }
+    return evaluateNetworkAccess({
+        address: params.address,
+        enabled: params.enabled,
+        expectedToken: params.expectedToken,
+        providedToken,
+    }).allow;
+}

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

@@ -629,6 +629,31 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 39,
+        name: 'add-network-access',
+        migrate: ({ global }) => {
+            // Opt-in LAN access with token auth. Disabled by default (localhost-only
+            // bind). Token is generated lazily on first enable via POST /network.
+            if (typeof global.networkAccessEnabled !== 'boolean') {
+                global.networkAccessEnabled = false;
+            }
+            if (typeof global.networkAccessToken !== 'string') {
+                global.networkAccessToken = '';
+            }
+        },
+    },
+    {
+        version: 40,
+        name: 'add-question-notification-sound',
+        migrate: ({ global }) => {
+            // Distinct sound played when the agent asks a question. Defaults to 'hey.mp3'
+            // so questions are audibly distinct from a customised task-done sound.
+            if (typeof global.audioQuestionSound !== 'string' || global.audioQuestionSound.length === 0) {
+                global.audioQuestionSound = 'hey.mp3';
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -675,9 +700,12 @@ function defaultSettings() {
             fileManagerCommand: '',
             terminalCommand: '',
             autoPurgeOnPrMerged: false,
+            networkAccessEnabled: false,
+            networkAccessToken: '',
             browserNotifications: true,
             audioNotifications: true,
             audioNotificationSound: 'hey.mp3',
+            audioQuestionSound: 'hey.mp3',
             audioNotificationVolume: 1,
             notionStatusProperty: '',
             notionInProgressStatus: '',
@@ -867,7 +895,7 @@ export function getSettings() {
     return readSettings();
 }
 /** Keys stripped from exports — secrets that should stay on the machine. */
-const SECRET_GLOBAL_KEYS = ['notionMcpKey', 'sentryMcpKey'];
+const SECRET_GLOBAL_KEYS = ['notionMcpKey', 'sentryMcpKey', 'networkAccessToken'];
 /** Build an export bundle with settings + templates. MCP keys are stripped. */
 export function exportConfigBundle(templates) {
     const settings = readSettings();
@@ -1033,6 +1061,7 @@ export function updateGlobalSettings(data) {
         'browserNotifications',
         'audioNotifications',
         'audioNotificationSound',
+        'audioQuestionSound',
         'audioNotificationVolume',
         'notionStatusProperty',
         'notionInProgressStatus',
@@ -1093,6 +1122,26 @@ export function updateGlobalSettings(data) {
     writeSettings(settings, { backup: true });
     return settings.global;
 }
+/**
+ * Persist network-access settings (enabled flag and/or token) directly.
+ *
+ * Network access is managed exclusively through this path (POST /api/settings/network),
+ * never the generic `updateGlobalSettings` allowlist: `networkAccessToken` is a secret
+ * (kept out of the allowlist so a config import can't inject one) and `networkAccessEnabled`
+ * is kept out too so it can't be flipped on via PUT /global without an accompanying token
+ * (which would leave the server bound wide but unauthenticatable after a restart).
+ */
+export function updateNetworkAccessSettings(patch) {
+    const settings = readSettings();
+    if (typeof patch.networkAccessEnabled === 'boolean') {
+        settings.global.networkAccessEnabled = patch.networkAccessEnabled;
+    }
+    if (typeof patch.networkAccessToken === 'string') {
+        settings.global.networkAccessToken = patch.networkAccessToken;
+    }
+    writeSettings(settings, { backup: true });
+    return settings.global;
+}
 function ensureGlobalWorktreesRootExists(worktreesPath) {
     const root = resolveGlobalWorktreesRoot(worktreesPath);
     if (!root || isNonNativeWindowsPath(root))

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

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { getTemplatesPath } from '../utils/paths.js';
-const CURRENT_FILE_VERSION = 1;
+const CURRENT_FILE_VERSION = 2;
 const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const MAX_CONTENT_LENGTH = 4096;
 const MAX_DESCRIPTION_LENGTH = 120;
@@ -117,10 +117,23 @@ function validateTemplateInput(input) {
         throw new Error(`Invalid content: must be 1..${MAX_CONTENT_LENGTH} chars`);
     }
 }
-function writeTemplates(templates) {
+function readSeededSlugs() {
+    const filePath = getTemplatesPath();
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return Array.isArray(parsed.seededDefaultSlugs) ? parsed.seededDefaultSlugs : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeTemplates(templates, seededDefaultSlugs) {
     const filePath = getTemplatesPath();
     mkdirSync(path.dirname(filePath), { recursive: true });
-    const file = { version: CURRENT_FILE_VERSION, templates };
+    const seeded = seededDefaultSlugs ?? readSeededSlugs() ?? [...LEGACY_DEFAULT_SLUGS];
+    const file = { version: CURRENT_FILE_VERSION, templates, seededDefaultSlugs: seeded };
     writeFileSync(filePath, JSON.stringify(file, null, 2), 'utf-8');
 }
 /**
@@ -154,6 +167,24 @@ export function replaceAllTemplates(templates) {
     }
     writeTemplates(validated);
 }
+/**
+ * The default slugs that existed BEFORE the seededDefaultSlugs watermark shipped.
+ * Bootstraps the watermark for pre-watermark installs so a default the user deleted
+ * earlier is not re-added on the first boot. Frozen historical snapshot; never change it.
+ */
+const LEGACY_DEFAULT_SLUGS = [
+    'kobo-context',
+    'review-quality',
+    'add-tests',
+    'explain',
+    'refactor',
+    'plan-tasks',
+    'show-tasks',
+    'mark-done',
+    'sync-tasks',
+    'pr-review-comments',
+    'ci-status',
+];
 export const DEFAULT_TEMPLATES = [
     {
         slug: 'kobo-context',
@@ -192,7 +223,9 @@ export const DEFAULT_TEMPLATES = [
             `# Boundaries\n` +
             `- The user owns the \`description\` field of the workspace — never write it; you only own \`agent_description\`\n` +
             `- The user can interrupt you at any time via the chat; treat their messages as authoritative redirections\n` +
-            `- Auto-loop is automatically disabled if the user sends a chat message during a loop — they'll re-enable it manually after\n`,
+            `- Auto-loop is automatically disabled if the user sends a chat message during a loop — they'll re-enable it manually after\n` +
+            `\n# Decision support\n` +
+            `For a high-stakes engineering decision with no obvious answer (architecture choice, risky refactor, a real tradeoff), run a "council": the \`/council\` template spawns 5 sub-agent advisors with distinct lenses, peer-reviews them, and synthesises a verdict into \`.ai/thoughts/\`. It costs ~11 sub-agent calls, so use it sparingly.\n`,
     },
     {
         slug: 'review-quality',
@@ -244,28 +277,64 @@ export const DEFAULT_TEMPLATES = [
         description: 'Check GitHub Actions status on PR',
         content: 'Check the CI/CD status for the pull request on branch {working_branch}.\n\nIf a PR exists (PR {pr_url}):\n1. Use the GitHub MCP tools to list the check runs / status checks on the latest commit of the PR\n2. For each check, report:\n   - Check name\n   - Status (queued, in_progress, completed)\n   - Conclusion (success, failure, neutral, skipped, etc.)\n   - Duration if available\n3. If any checks failed, fetch the logs or annotations and summarize what went wrong\n4. Give an overall summary: all green, some failing, or still running\n\nIf no PR exists, say so and suggest creating one first.',
     },
+    {
+        slug: 'council',
+        description: 'Pressure-test a high-stakes decision with 5 sub-agent advisors',
+        content: `Run a "council" to pressure-test a high-stakes decision for this workspace ("{workspace_name}").\n\n` +
+            `The decision: take what the user described in this message. If they gave none, ask for it in one line and stop.\n\n` +
+            `You orchestrate this with your own sub-agents:\n\n` +
+            `1. Spawn 5 sub-agents IN PARALLEL, one per lens. Each answers the decision independently in 150-300 words, fully in its lens, no hedging, no false balance:\n` +
+            `   - Contrarian: hunt the fatal flaw; what fails, what's missing.\n` +
+            `   - First Principles: ignore the surface question; what are we really solving? Is this even the right question?\n` +
+            `   - Expansionist: the upside everyone misses; what if it works better than expected?\n` +
+            `   - Outsider: zero context; react only to what's stated; catch the curse of knowledge.\n` +
+            `   - Executor: can it be done, and what's the fastest first step Monday morning?\n\n` +
+            `2. Anonymise the 5 answers as A-E (randomised). Spawn 5 reviewer sub-agents; each names the strongest answer, the biggest blind spot, and what ALL of them missed. Under 200 words each.\n\n` +
+            `3. Synthesise the verdict yourself:\n` +
+            `   - Where the council agrees (high-confidence signals).\n` +
+            `   - Where it clashes (present both sides honestly).\n` +
+            `   - Blind spots the review caught.\n` +
+            `   - One clear recommendation, not "it depends".\n` +
+            `   - The one thing to do first.\n\n` +
+            `4. Post the verdict in chat, and save the full transcript (decision, 5 answers, 5 reviews, verdict) to \`.ai/thoughts/council-<short-topic-slug>.md\`.\n\n` +
+            `Cost: this runs ~11 sub-agent calls. Use it only for decisions that are expensive to get wrong, not routine choices.\n`,
+    },
 ];
 function seedTemplates() {
     const now = new Date().toISOString();
     const seed = DEFAULT_TEMPLATES.map((t) => ({ ...t, createdAt: now, updatedAt: now }));
-    writeTemplates(seed);
+    writeTemplates(seed, DEFAULT_TEMPLATES.map((t) => t.slug));
 }
+/**
+ * Add any default whose slug was never seeded into this install AND is not already
+ * present. Each default seeds at most once (tracked in `seededDefaultSlugs`), so a
+ * default the user deleted does not come back. Never overwrites an existing template.
+ */
 export function reloadDefaultTemplates() {
     const existing = listTemplates();
-    const existingBySlug = new Map(existing.map((t) => [t.slug, t]));
+    const existingBySlug = new Set(existing.map((t) => t.slug));
+    const rawSeeded = readSeededSlugs();
+    const seeded = new Set(rawSeeded ?? LEGACY_DEFAULT_SLUGS);
     const now = new Date().toISOString();
     const added = [];
     const kept = [];
     const next = [...existing];
     for (const def of DEFAULT_TEMPLATES) {
-        if (existingBySlug.has(def.slug)) {
+        if (seeded.has(def.slug)) {
             kept.push(def.slug);
             continue;
         }
-        next.push({ ...def, createdAt: now, updatedAt: now });
-        added.push(def.slug);
+        if (existingBySlug.has(def.slug)) {
+            kept.push(def.slug);
+        }
+        else {
+            next.push({ ...def, createdAt: now, updatedAt: now });
+            added.push(def.slug);
+        }
+        seeded.add(def.slug);
+    }
+    if (added.length > 0 || rawSeeded === undefined) {
+        writeTemplates(next, [...seeded]);
     }
-    if (added.length > 0)
-        writeTemplates(next);
     return { added, kept };
 }

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

@@ -71,6 +71,15 @@ export function getPending(workspaceId) {
         return null;
     }
 }
+/**
+ * Whether a wakeup is currently scheduled for the workspace. Used to decide
+ * that background work the agent left running is intentional (the wakeup will
+ * resume the session to check it) and must NOT be torn down — e.g. the engine's
+ * result-drain watchdog skips its abort when this is true.
+ */
+export function isWakeupScheduled(workspaceId) {
+    return getPending(workspaceId) !== null;
+}
 /** Re-register timers for rows persisted across restart. Skips stale entries. */
 export function rehydrate() {
     try {

package/dist/server/services/worktree-purge-service.js

@@ -6,7 +6,7 @@ import { resolveForge } from './forge/resolve.js';
 import { destroyTerminal } from './terminal-service.js';
 import { emitEphemeral } from './websocket-service.js';
 import { archiveWorkspace, getWorkspace, markWorktreePurged, } from './workspace-service.js';
-import { removeWorktree } from './worktree-service.js';
+import { isPermissionError, removeWorktree } from './worktree-service.js';
 export async function purgeWorktree(workspaceId) {
     const workspace = getWorkspace(workspaceId);
     if (!workspace)
@@ -71,7 +71,7 @@ export async function purgeWorktree(workspaceId) {
     return { outcome: 'purged', warnings };
 }
 function buildRemovalFailureMessage(worktreePath, projectPath, errMsg) {
-    const isPermission = /EACCES|EPERM|permission denied|operation not permitted/i.test(errMsg);
+    const isPermission = isPermissionError(errMsg);
     const baseLine = `Failed to remove worktree '${worktreePath}'.`;
     const recovery = ['Recovery:', `  sudo rm -rf '${worktreePath}'`, `  cd '${projectPath}' && git worktree prune`].join('\n');
     if (isPermission) {