@loicngr/kobo 1.7.16 → 1.7.18

package/dist/server/routes/workspaces.js

@@ -11,12 +11,19 @@ import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as archiveScriptService from '../services/archive-script-service.js';
 import * as autoLoopService from '../services/auto-loop-service.js';
+import { changeSourceBranch } from '../services/change-source-branch-service.js';
+import { listChatHistory, pushChatHistory } from '../services/chat-history-service.js';
 import * as cronService from '../services/cron-service.js';
 import * as devServerService from '../services/dev-server-service.js';
+import { saveWorkspaceFile, shaOf } from '../services/file-editor-service.js';
+import { getForgeProvider } from '../services/forge/registry.js';
+import { resolveForge } from '../services/forge/resolve.js';
+import { ForgeUnavailableError } from '../services/forge/types.js';
+import { computeGitStats } from '../services/git-stats-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 { getAllPrSnapshots, refreshPrSnapshot } from '../services/pr-watcher-service.js';
+import { getAllGitStats, getAllPrSnapshots, refreshPrSnapshot } from '../services/pr-watcher-service.js';
 import * as quotaBackoffService from '../services/quota-backoff-service.js';
 import { getActiveReviewTemplate, renderReviewTemplate } from '../services/review-template-service.js';
 import * as sentryService from '../services/sentry-service.js';
@@ -622,8 +629,8 @@ app.post('/', migrationGuard, async (c) => {
                 brainstormPrompt += `- mark_task_done(task_id) — mark a task or criterion as done\n`;
                 brainstormPrompt += `\nAs you work, keep the task list up to date: call mark_task_done(task_id) as soon as you complete a task or validate a criterion — don't wait until the end. Call list_tasks() first to see the current IDs.\n`;
             }
-            if (body.notionUrl) {
-                brainstormPrompt += `- get_notion_ticket() — retrieve the Notion ticket info (URL, ticket ID, extracted content)\n`;
+            if (body.notionUrl || body.sentryUrl) {
+                brainstormPrompt += `- get_ticket() — retrieve the mission's source-of-truth (source URL + extracted ticket/issue content), whether it comes from Notion or Sentry\n`;
             }
             brainstormPrompt += `- kobo__set_workspace_agent_description(description) — keep the workspace's agent_description up to date as a short one-line summary of what you're currently doing or have just accomplished. The user sees this in the sidebar without opening the workspace. Update it whenever your focus shifts (e.g. "Investigating SERVICE-1600 → enriching local Notion file", then "Writing failing test for FacturX validator"). Plain text, max 200 chars. The current value is in kobo__get_workspace_info.\nThere is also a separate user-controlled \`description\` field on the workspace — DO NOT touch it. Only set_workspace_agent_description is yours to write; the user owns the other one.\n`;
             brainstormPrompt += `- kobo__cron_create(expression, prompt, label?, mode?, oneShot?) — schedule a (recurring or one-shot) trigger on THIS workspace. At each fire Kōbō waits for the workspace to be idle and then injects \`prompt\` as the next user message. \`expression\` is a standard 5-field cron (\`min hour dom month dow\`) or a helper (\`@hourly\`, \`@daily\`, \`@weekly\`, \`@monthly\`, \`@yearly\`). Examples: \`*/30 * * * *\` = every 30 min; \`0 9 * * 1\` = every Monday at 9am; \`0 14 7 6 *\` = 7 June at 14:00. \`mode\` is \`'resume'\` (default — every fire continues the SAME conversation that scheduled the cron, so you can chain follow-ups) or \`'fresh'\` (every fire starts a brand-new session with a clean context, ideal for periodic checks like CI watch). \`oneShot\` (default false): when true, the cron cancels itself after the first real fire — use this to trigger once at a specific time without recurring. Skip-if-active: occurrences fired while a session is running are skipped, the next is computed, and the cron continues. Persists across restarts. Returns a cron \`id\`.\n`;
@@ -770,6 +777,23 @@ app.get('/pr-states', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/workspaces/info — bulk snapshot for the 30s client refresh:
+// non-archived workspace rows + cached PR snapshots + cached git stats.
+// Pure read — no git/forge calls on the request path. Static route: must
+// stay before GET /:id.
+app.get('/info', (c) => {
+    try {
+        return c.json({
+            workspaces: workspaceService.listWorkspaces(false),
+            prSnapshots: getAllPrSnapshots(),
+            gitStats: getAllGitStats(),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // POST /api/workspaces/pr-snapshot/refresh/:id — on-demand refresh of a single
 // workspace's PR snapshot, driven by the Git tab refresh button. Static prefix
 // keeps it ahead of `/:id` in the Hono matcher.
@@ -1443,6 +1467,81 @@ ${AUTO_LOOP_HARD_RULES}`;
         return c.json({ error: message }, 500);
     }
 });
+// GET /:id/chat-history — list up to 200 most recent chat-input messages
+// for this workspace, ordered newest-first. Placed BEFORE `app.get('/:id', …)`
+// so the more-specific path wins.
+app.get('/:id/chat-history', (c) => {
+    try {
+        const id = c.req.param('id');
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        return c.json({ history: listChatHistory(id) });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /:id/chat-history — append a message to this workspace's history.
+// Body: { message: string }. 204 on success.
+app.post('/:id/chat-history', 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);
+        if (workspace.archivedAt) {
+            return c.json({ error: `Workspace '${id}' is archived` }, 400);
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (typeof body.message !== 'string' || body.message.trim().length === 0) {
+            return c.json({ error: 'message is required' }, 400);
+        }
+        pushChatHistory(id, body.message);
+        return c.body(null, 204);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+// POST /:id/save-file — persist edited file content from the diff viewer.
+// Body: { path, content, baseSha }. Refuses while the agent runs (409). When
+// the file's current sha differs from baseSha, returns 412 with `currentSha`.
+app.post('/:id/save-file', 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);
+        if (workspace.archivedAt) {
+            return c.json({ error: `Workspace '${id}' is archived` }, 400);
+        }
+        if (agentManager.getAgentStatus(id) !== null) {
+            return c.json({ error: 'Cannot save while the agent is running — stop it first' }, 409);
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (typeof body.path !== 'string' || body.path.trim().length === 0) {
+            return c.json({ error: 'path is required' }, 400);
+        }
+        if (typeof body.content !== 'string') {
+            return c.json({ error: 'content is required (string)' }, 400);
+        }
+        if (typeof body.baseSha !== 'string' || body.baseSha.length === 0) {
+            return c.json({ error: 'baseSha is required' }, 400);
+        }
+        const result = saveWorkspaceFile(workspace.worktreePath, body.path, body.content, body.baseSha);
+        if (result.status === 'conflict') {
+            return c.json({ error: 'File changed on disk', currentSha: result.currentSha }, 412);
+        }
+        return c.body(null, 204);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/workspaces/:id — get workspace details with tasks
 app.get('/:id', (c) => {
     try {
@@ -1914,33 +2013,18 @@ app.get('/:id/git-stats', async (c) => {
         if (!workspace) {
             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);
+            await gitOps.fetchSourceBranchAsync(workspace.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, workspace.workingBranch);
-        const workingTree = gitOps.getWorkingTreeStatus(worktreePath);
-        return c.json({
-            commitCount,
-            behindCount,
-            filesChanged: diffStats.filesChanged,
-            insertions: diffStats.insertions,
-            deletions: diffStats.deletions,
-            prUrl: pr?.url ?? null,
-            prState: pr?.state ?? null,
-            unpushedCount,
-            workingTree,
-        });
+            // Fire-and-forget: explicitly catch to avoid unhandled rejection.
+            void gitOps.fetchSourceBranchAsync(workspace.worktreePath, workspace.sourceBranch).catch(() => { });
+        }
+        const forgeProvider = getForgeProvider(resolveForge(workspace.projectPath));
+        const pr = await forgeProvider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
+        const stats = await computeGitStats(workspace, pr);
+        return c.json(stats);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -2002,7 +2086,13 @@ app.get('/:id/diff-file', (c) => {
         const original = gitOps.getFileAtRef(worktreePath, baseRef, filePath);
         const modified = gitOps.getFileContent(worktreePath, filePath);
         c.header('Cache-Control', 'no-store');
-        return c.json({ original: original ?? '', modified: modified ?? '', filePath, mode });
+        return c.json({
+            original: original ?? '',
+            modified: modified ?? '',
+            filePath,
+            mode,
+            modifiedSha: shaOf(modified ?? ''),
+        });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -2341,7 +2431,9 @@ app.post('/:id/git/resolve-with-agent', migrationGuard, async (c) => {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             return c.json({ error: `Workspace '${id}' not found` }, 404);
-        const body = (await c.req.json().catch(() => ({})));
+        const body = (await c.req
+            .json()
+            .catch(() => ({})));
         const worktreePath = workspace.worktreePath;
         const operation = body.operation ?? gitOps.getOngoingGitOperation(worktreePath) ?? 'merge';
         const files = body.files && body.files.length > 0 ? body.files : gitOps.getConflictedFiles(worktreePath);
@@ -2349,7 +2441,16 @@ app.post('/:id/git/resolve-with-agent', migrationGuard, async (c) => {
             return c.json({ error: 'No conflicted files detected — nothing for the agent to resolve' }, 400);
         }
         const fileList = files.map((f) => `- ${f}`).join('\n');
-        const continueCmd = operation === 'merge' ? 'git merge --continue' : 'git rebase --continue';
+        const continueCmd = operation === 'merge'
+            ? 'git merge --continue'
+            : operation === 'cherry-pick'
+                ? 'git cherry-pick --continue'
+                : 'git rebase --continue';
+        // During a cherry-pick the conflict sides are inverted vs a rebase:
+        // `ours` = the new base, `theirs` = the feature commit being applied.
+        const cherryPickNote = operation === 'cherry-pick'
+            ? '\n\n**Cherry-pick note:** during a cherry-pick, `ours` is the new base branch and `theirs` is our feature commit being replayed — the inverse of a rebase. `git checkout --theirs <file>` takes OUR feature version.'
+            : '';
         const prompt = `I started a \`git ${operation}\` of \`origin/${workspace.sourceBranch}\` into our working branch \`${workspace.workingBranch}\` and it produced conflicts that I need your help to resolve INTELLIGENTLY.
 
 Conflicted files (${files.length}):
@@ -2371,7 +2472,7 @@ ${fileList}
 3. Edit the file to the correct merged state and remove the conflict markers.
 4. Run the test suite to verify no regression (\`npm test\` or the project's equivalent).
 5. \`git add <resolved-files>\` then \`${continueCmd}\`.
-6. Report the summary: which files you touched, the key decisions you made, and the final test result.
+6. Report the summary: which files you touched, the key decisions you made, and the final test result.${cherryPickNote}
 
 Start now.`;
         // Persist the prompt in the chat feed so the user sees what was dispatched.
@@ -2403,7 +2504,7 @@ Start now.`;
         return c.json({ error: message }, 500);
     }
 });
-/** Change the base branch of an existing PR via gh CLI. */
+/** Change the base branch of an existing PR via the resolved forge provider. */
 app.post('/:id/change-pr-base', async (c) => {
     try {
         const id = c.req.param('id');
@@ -2413,8 +2514,90 @@ app.post('/:id/change-pr-base', async (c) => {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             return c.json({ error: `Workspace '${id}' not found` }, 404);
-        const worktreePath = workspace.worktreePath;
-        await execFileAsync('gh', ['pr', 'edit', '--base', body.base], { cwd: worktreePath });
+        const provider = getForgeProvider(resolveForge(workspace.projectPath));
+        if (!provider.capabilities.canChangePrBase) {
+            return c.json({ error: 'This project has no forge that supports changing the PR base', code: 'forge_unsupported' }, 409);
+        }
+        const availability = await provider.isAvailable(workspace.worktreePath);
+        if (!availability.available) {
+            return c.json({
+                error: `Forge CLI unavailable (${availability.reason ?? 'unknown'})`,
+                code: `forge_${availability.reason ?? 'unavailable'}`,
+            }, 409);
+        }
+        await provider.changePrBase(workspace.worktreePath, body.base);
+        return c.json({ success: true });
+    }
+    catch (err) {
+        if (err instanceof ForgeUnavailableError) {
+            return c.json({ error: err.message, code: 'forge_unavailable' }, 409);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+/** Re-target a workspace onto a new source branch (metadata + worktree + PR base). */
+app.post('/:id/change-source-branch', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        if (!body.newBase)
+            return c.json({ error: 'Missing newBase parameter' }, 400);
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const result = await changeSourceBranch(id, body.newBase);
+        if (result.status === 'too-many') {
+            return c.json({ error: 'The branch has too many own commits — rebase it manually', code: 'too_many_commits', ...result }, 409);
+        }
+        if (result.status === 'dirty') {
+            return c.json({ error: 'Commit or stash your changes before changing the source branch', code: 'dirty_worktree', ...result }, 409);
+        }
+        return c.json(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (/agent is running/i.test(message)) {
+            return c.json({ error: message, code: 'agent_running' }, 409);
+        }
+        if (/does not exist|already '|is required/i.test(message)) {
+            return c.json({ error: message }, 400);
+        }
+        return c.json({ error: message }, 500);
+    }
+});
+/** Cancel an in-flight source-branch change: abort the cherry-pick, restore the
+ *  working branch from its latest backup branch, revert the source metadata. */
+app.post('/:id/cancel-source-change', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        if (!body.previousBase)
+            return c.json({ error: 'Missing previousBase parameter' }, 400);
+        const workspace = workspaceService.getWorkspace(id);
+        if (!workspace)
+            return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const backups = gitOps.listBackupBranches(workspace.worktreePath, workspace.workingBranch);
+        if (backups.length === 0) {
+            return c.json({ error: 'No backup branch found — cannot auto-restore', code: 'no_backup' }, 409);
+        }
+        gitOps.restoreBranchFromBackup(workspace.worktreePath, workspace.workingBranch, backups[0]);
+        workspaceService.updateWorkspaceSourceBranch(id, body.previousBase);
+        return c.json({ success: true, restoredFrom: backups[0] });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
+/** Force-push the working branch with --force-with-lease (after a history rewrite). */
+app.post('/:id/force-push', (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.pushBranch(workspace.worktreePath, workspace.workingBranch, { force: true });
         return c.json({ success: true });
     }
     catch (err) {
@@ -2463,36 +2646,39 @@ app.post('/:id/open-pr', async (c) => {
             }
             return c.json({ error: `Failed to check branch state: ${message}` }, 500);
         }
-        // Create PR via GitHub CLI
-        let ghOutput;
+        // Create the PR/MR via the resolved forge provider.
+        const provider = getForgeProvider(resolveForge(workspace.projectPath));
+        if (!provider.capabilities.canCreatePr) {
+            return c.json({ error: 'This project has no forge that can open a PR', code: 'forge_unsupported' }, 409);
+        }
+        const availability = await provider.isAvailable(worktreePath);
+        if (!availability.available) {
+            return c.json({
+                error: `Forge CLI unavailable (${availability.reason ?? 'unknown'})`,
+                code: `forge_${availability.reason ?? 'unavailable'}`,
+            }, 409);
+        }
+        let prUrl;
+        let prNumber;
         try {
             const placeholderBody = 'Automated PR — description will be updated by the agent.';
-            const { stdout } = await execFileAsync('gh', [
-                'pr',
-                'create',
-                '--base',
-                workspace.sourceBranch,
-                '--head',
-                workspace.workingBranch,
-                '--title',
-                workspace.name,
-                '--body',
-                placeholderBody,
-            ], { cwd: worktreePath });
-            ghOutput = stdout;
+            const created = await provider.createPr(worktreePath, {
+                base: workspace.sourceBranch,
+                head: workspace.workingBranch,
+                title: workspace.name,
+                body: placeholderBody,
+            });
+            prUrl = created.url;
+            prNumber = created.number;
         }
         catch (err) {
+            if (err instanceof ForgeUnavailableError) {
+                return c.json({ error: err.message, code: 'forge_unavailable' }, 409);
+            }
             const message = err instanceof Error ? err.message : String(err);
             const stderr = err.stderr?.toString() ?? '';
-            return c.json({ error: `gh pr create failed: ${message} ${stderr}`.trim() }, 500);
-        }
-        // Parse PR URL and number from gh output
-        const urlMatch = ghOutput.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
-        if (!urlMatch) {
-            return c.json({ error: 'Could not parse PR URL from gh output' }, 500);
+            return c.json({ error: `Failed to open PR: ${message} ${stderr}`.trim() }, 500);
         }
-        const prUrl = urlMatch[0];
-        const prNumber = parseInt(urlMatch[1], 10);
         // ── From here on, PR exists. No more 5xx responses. ──
         // Resolve the PR prompt template; skip message steps if empty
         const effective = settingsService.getEffectiveSettings(workspace.projectPath);

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

@@ -5,6 +5,14 @@ import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from '.
 import { buildClaudeOptions } from './options-builder.js';
 import { buildPreCompactCustomInstructions } from './precompact-hook.js';
 import { resolveClaudeBinaryPath } from './resolve-binary.js';
+/**
+ * Grace window between the SDK's terminal `result` message and the generator
+ * reaching `done`. A healthy run closes within milliseconds; if the generator
+ * stays parked past this (a hung subagent task or stuck MCP/teardown), the
+ * post-result drain watchdog force-emits `session:ended` so the orchestrator
+ * and auto-loop are not frozen forever.
+ */
+const RESULT_DRAIN_TIMEOUT_MS = 15_000;
 function toMcpServersMap(specs) {
     if (!specs || specs.length === 0)
         return undefined;
@@ -139,6 +147,37 @@ export function createClaudeCodeEngine() {
             };
             let iteratorRunning = false;
             let userInterrupted = false;
+            // Guard so the post-result drain watchdog and the natural loop exit (or
+            // catch block) never both emit `session:ended` for the same run.
+            let sessionEndedEmitted = false;
+            const emitSessionEnded = (reason, exitCode) => {
+                if (sessionEndedEmitted)
+                    return;
+                sessionEndedEmitted = true;
+                safeEmit({ kind: 'session:ended', reason, exitCode });
+            };
+            // Post-result drain watchdog. The SDK emits a terminal `result` message
+            // when the turn completes; the generator should then reach `done`
+            // near-instantly. If it stays parked (a hung subagent task or stuck
+            // teardown), the `for await` below would wait forever — `session:ended`
+            // would never fire, freezing the orchestrator and the auto-loop. Once a
+            // `result` is observed we arm a timer that force-emits `session:ended`
+            // with the result's own outcome, then aborts the generator best-effort.
+            let resultDrainTimer;
+            const armResultDrainWatchdog = () => {
+                if (resultDrainTimer)
+                    return;
+                resultDrainTimer = setTimeout(() => {
+                    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();
+                }, RESULT_DRAIN_TIMEOUT_MS);
+                resultDrainTimer.unref?.();
+            };
             const iteratorPromise = (async () => {
                 iteratorRunning = true;
                 try {
@@ -149,6 +188,8 @@ export function createClaudeCodeEngine() {
                                 discoveredSessionId = ev.engineSessionId;
                             safeEmit(ev);
                         }
+                        if (msg.type === 'result')
+                            armResultDrainWatchdog();
                     }
                     // If the SDK ended with a `result.subtype === 'error_*'`, the
                     // event-mapper already surfaced an `error` event but the iterator
@@ -158,11 +199,7 @@ export function createClaudeCodeEngine() {
                     // `error_during_execution`, which the mapper suppresses) — report
                     // it as `killed`, consistent with the catch-block abort path.
                     const endReason = userInterrupted ? 'killed' : mapperState.sawErrorResult ? 'error' : 'completed';
-                    safeEmit({
-                        kind: 'session:ended',
-                        reason: endReason,
-                        exitCode: endReason === 'completed' ? 0 : null,
-                    });
+                    emitSessionEnded(endReason, endReason === 'completed' ? 0 : null);
                 }
                 catch (err) {
                     // Treat any abort we triggered (stop() → abortController.abort()) as
@@ -174,7 +211,7 @@ export function createClaudeCodeEngine() {
                         abortController.signal.aborted ||
                         /aborted by user|process aborted|abortError|ede_diagnostic/i.test(error.message ?? '');
                     if (isAbort) {
-                        safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
+                        emitSessionEnded('killed', null);
                     }
                     else {
                         safeEmit({
@@ -182,10 +219,17 @@ export function createClaudeCodeEngine() {
                             category: 'spawn_failed',
                             message: error.message,
                         });
-                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                        emitSessionEnded('error', null);
                     }
                 }
                 finally {
+                    // The post-result drain watchdog (if armed) is moot once the
+                    // iterator has exited — clear it so a healthy run never triggers a
+                    // stray abort after it already ended.
+                    if (resultDrainTimer) {
+                        clearTimeout(resultDrainTimer);
+                        resultDrainTimer = undefined;
+                    }
                     // Drain any callback still pending (SDK terminated while awaiting an
                     // answer). canUseTool's abort path covers signalled stops; this
                     // covers natural iterator completion.

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

@@ -6,9 +6,9 @@ const KOBO_MCP_BRIEF = [
     'Conventions — read these BEFORE starting work, not as a fallback:',
     '• `kobo__list_tasks` first on any non-trivial turn, then `kobo__mark_task_done` as each item completes.',
     '• `kobo__list_documents` / `kobo__read_document` to discover existing plans and specs under docs/ and .ai/thoughts/ before writing new ones.',
-    '• `kobo__log_thought` to persist notable decisions to `.ai/thoughts/<date>-<slug>.md`.',
+    '• `kobo__log_thought` to persist notable decisions to `.ai/thoughts/logs/<date>-<slug>.md`.',
     '• `kobo__search_codebase` to recall prior chat history (conversations, not source — use Grep for source).',
-    '• `kobo__get_workspace_info` / `kobo__get_git_info` / `kobo__get_notion_ticket` for context.',
+    '• `kobo__get_workspace_info` / `kobo__get_git_info` / `kobo__get_ticket` for context.',
     '• `kobo__set_workspace_status` when the mission is done / blocked / idle.',
     '• `kobo__schedule_wakeup` / `kobo__cancel_wakeup` to schedule (or cancel) a follow-up session — prefer these over the built-in `ScheduleWakeup` tool.',
     'Each tool carries its own "WHEN to use" guidance in its description — follow it.',

package/dist/server/services/agent/engines/codex/options-builder.js

@@ -4,9 +4,9 @@ const CODEX_KOBO_MCP_BRIEF = [
     'Conventions — read these BEFORE starting work, not as a fallback:',
     '• `mcp__kobo-tasks__list_tasks` first on any non-trivial turn, then `mcp__kobo-tasks__mark_task_done` as each item completes.',
     '• `mcp__kobo-tasks__list_documents` / `mcp__kobo-tasks__read_document` to discover existing plans and specs under docs/ and .ai/thoughts/ before writing new ones.',
-    '• `mcp__kobo-tasks__log_thought` to persist notable decisions to `.ai/thoughts/<date>-<slug>.md`.',
+    '• `mcp__kobo-tasks__log_thought` to persist notable decisions to `.ai/thoughts/logs/<date>-<slug>.md`.',
     '• `mcp__kobo-tasks__search_codebase` to recall prior chat history (conversations, not source — use shell tools for source).',
-    '• `mcp__kobo-tasks__get_workspace_info` / `mcp__kobo-tasks__get_git_info` / `mcp__kobo-tasks__get_notion_ticket` for context.',
+    '• `mcp__kobo-tasks__get_workspace_info` / `mcp__kobo-tasks__get_git_info` / `mcp__kobo-tasks__get_ticket` for context.',
     '• `mcp__kobo-tasks__set_workspace_status` when the mission is done / blocked / idle.',
     '• `mcp__kobo-tasks__schedule_wakeup` / `mcp__kobo-tasks__cancel_wakeup` to schedule (or cancel) a follow-up session.',
     'Each tool carries its own "WHEN to use" guidance in its description — follow it.',

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

@@ -313,6 +313,7 @@ function readEffectiveSettingsSafe(projectPath) {
             cleanupScriptMode: 'no-tasks',
             cleanupScriptOnlyOnChanges: false,
             archiveScript: '',
+            changeSourceBranchScript: '',
             notionStatusProperty: '',
             notionInProgressStatus: '',
         };