@loicngr/kobo 2.1.23 → 2.1.25

package/AGENTS.md

@@ -223,6 +223,13 @@ reopen a closed database. Startup reconciles lost internal reporters while
 preserving external ones. An interrupted reporter is not proof of cancelled
 background work. Operational reporting never satisfies auto-loop verification.
 
+Progress without measured counts is labelled explicitly, and the panel shows the
+age of a report after two minutes without a newer one. This local clock must not
+poll or mutate progress. Claude's per-launch PostToolUse advisory tracks only
+observed managed progress responses, separates parent/subagent producers, and
+limits reminders by action count and elapsed time. Do not infer percentages,
+automatically complete bars, or block agent shutdown for missing reports.
+
 Retain scoped activity-key fingerprints, producer sequences and dismissed rows
 for retries; subsequent updates cannot resurrect a dismissed indicator or undo a
 terminal state. Bound labels, steps, page size, active/retained records and update
@@ -243,7 +250,23 @@ Claude SDK `task_*` messages cover agents **and** background jobs. Preserve `tas
 
 ### External MCP dialogue and update checks
 
-Workspace-bound stdio, global stdio and HTTP expose shared `create_workspace` / `diagnose_workspace_pr` definitions in `src/shared/workspace-creation-tools.ts`. Stdio forwards them to the backend. `workspace-creation-mcp-service.ts` validates inputs and dispatches through the existing workspace and PR routes in process; preserve UI validation, checkout fingerprints, lifecycle guards and rollback. Inputs use snake_case except the existing camelCase PR checkout decisions. Attachments are inline base64, bounded to the shared 10-file/50 MiB decoded limit before checkout mutations. Keep SDK HTTP/stdio limits aligned with the shared creation envelope budget. Only creation envelopes get the larger base64 HTTP body budget; ordinary MCP requests remain 1 MiB. After a known PR creation failure, rollback only a checkout proven newly created, unchanged, clean (including ignored files) and unowned, under the Git repository lock; retain other checkouts and expose recovery details. Do not retry uncertain creation automatically or treat `creation_id` as an idempotency key. Restricted review/handoff launches cannot create workspaces or invoke lifecycle mutations. Shared lifecycle tools (`workspace-lifecycle-tools.ts` / `workspace-lifecycle-mcp-service.ts`) also expose archive, purge, delete, unarchive and restore through the same transports. Reject reserved/bulk/path-like IDs, require explicit purge/delete flags, and preserve warnings. Single-workspace DELETE accepts optional `confirmationBranch`, rechecked under its lifecycle guard before stopping processes; MCP always supplies it. Branch rename/resync share this guard so the confirmed branch and checkout path cannot change during teardown. Recovery uses `restore-worktree` before unarchive and never starts an agent.
+Workspace-bound stdio, global stdio and HTTP expose shared `create_workspace` / `diagnose_workspace_pr` definitions in `src/shared/workspace-creation-tools.ts`. Stdio forwards them to the backend. `workspace-creation-mcp-service.ts` validates inputs and dispatches through the existing workspace and PR routes in process; preserve UI validation, checkout fingerprints, lifecycle guards and rollback. Inputs use snake_case except the existing camelCase PR checkout decisions. Attachments are inline base64, bounded to the shared 10-file/50 MiB decoded limit before checkout mutations. Keep SDK HTTP/stdio limits aligned with the shared creation envelope budget. Creation and send_workspace_message envelopes with attachments get the larger base64 HTTP body budget; ordinary MCP requests remain 1 MiB. After a known PR creation failure, rollback only a checkout proven newly created, unchanged, clean (including ignored files) and unowned, under the Git repository lock; retain other checkouts and expose recovery details. Do not retry uncertain creation automatically or treat `creation_id` as an idempotency key. Restricted review/handoff launches cannot create workspaces or invoke lifecycle mutations. Shared lifecycle tools (`workspace-lifecycle-tools.ts` / `workspace-lifecycle-mcp-service.ts`) also expose archive, purge, delete, unarchive and restore through the same transports. Reject reserved/bulk/path-like IDs, require explicit purge/delete flags, and preserve warnings. Single-workspace DELETE accepts optional `confirmationBranch`, rechecked under its lifecycle guard before stopping processes; MCP always supplies it. Branch rename/resync share this guard so the confirmed branch and checkout path cannot change during teardown. Recovery uses `restore-worktree` before unarchive and never starts an agent.
+
+MCP creation and single-workspace messages share `shared/mcp-attachments.ts`
+validation and inline `{name, mime_type, data_base64}` schemas. Validate before
+writing, reserve keyed-message identity before uploading, and fingerprint the
+original content/session plus attachment names, types and bytes (preserving old
+text-only fingerprints). Delivery saves files under the target worktree using
+the existing attachment service, then passes references to the engine and chat.
+Clean up definitively rejected files; retain them if dispatch is uncertain.
+Never expose raw server filesystem paths as attachment inputs. Group messages
+remain text-only.
+
+The global JSON setting `forceImmediateMessages` (v67, default false) bypasses
+client chat queueing for new messages using confirmed immediate delivery. It
+also bypasses the auto-loop next-iteration UI path; normal backend immediate
+message delivery pauses a ready loop. Do not flush existing queues on toggle,
+remove compaction/permission/handoff guards, or queue rejected forced sends.
 
 `POST /api/mcp` exposes stateless Streamable HTTP discovery/dialogue tools, behind the existing Host/Origin and network-token gates. The global stdio server forwards dialogue calls through this backend so agent runtime ownership remains centralized. `workspace-message-service.ts` shares delivery with WebSocket chat.
 
@@ -654,6 +677,14 @@ reuse outside PR import still forces setup off. Worktree ownership is unchanged.
 
 Each event maps to one effective-settings key (`sessionEndedScript` / `prMergedScript` / `autoLoopDisabledScript`, settings migration v55), cascading project-over-global with empty meaning inherit. Execution reuses `runScript` with `eventPrefix: 'hook:<event>'`; `runScript` gained an `extraEnv` option, merged **under** the identity variables so a hook payload can never claim a different `WORKSPACE_ID`. `runLifecycleHook` never rejects and returns `null` when there is nothing to run (no script, unknown workspace, worktree gone). The pr-watcher awaits the `pr-merged` hook before auto-purge so a deploy script does not lose its worktree mid-run. See [CONFIGURATION.md → Lifecycle hooks](CONFIGURATION.md#lifecycle-hooks).
 
+The shared `utils/script-runner.ts` supplies `INSTANCE` and `PROJECT_NAME` to
+setup, cleanup, archive and every lifecycle hook, including shutdown. Resolve
+these at execution time through `utils/dev-server-instance.ts`, shared with the
+dev-server service. Never inherit ambient Docker identity or invent a Compose
+project name: `PROJECT_NAME` is empty when no matching instance metadata exists.
+`ScriptVariablesHelp.vue` documents common and event-specific variables in both
+global and project settings; keep this help and CONFIGURATION.md in sync.
+
 ### Engine comparison
 
 Successful paired creation opens the existing `split` route with `left` and `right` workspace ids in creation order. A single successful creation keeps the normal workspace route, including when the second creation fails.
@@ -723,6 +754,14 @@ Snapshot each target and its delivery mode before scheduling: auto-loop uses `ne
 
 ### File editing in the diff viewer
 
+The diff defaults to inline view. Busy workspace status or known live controller disables
+Edit with an explanatory tooltip, and updates Monaco to read-only without discarding
+the current buffer. Historical commit comparisons remain read-only. Unpushed mode
+lists local commits plus working-tree changes (including non-ignored untracked files)
+against the branch remote ref, falling back to the source branch before the first push.
+The list and file-content routes must use the same baseline semantics; failed Git
+reads must not be reported as an empty, clean diff.
+
 The right panel of `DiffViewer.vue` is editable when the workspace agent is stopped and the file is not in `deleted` status. `Ctrl/Cmd+S` or the explicit Save button persists the file via `POST /api/workspaces/:id/save-file`, sending `{ path, content, baseSha }` where `baseSha` is the sha256 captured at `GET /diff-file` time. The route refuses with **412 Precondition Failed** + `{ currentSha }` if the on-disk content has changed; the client shows a Reload / Keep mine dialog. Worktree-traversal guards (including parent-symlink escapes) and a 1 MB size cap live in `file-editor-service.ts`. Changing files in the tree while dirty pops an "Unsaved changes" prompt.
 
 ## Code conventions

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 2.1.25
+
+- feat: improve merge options, diff controls and progress reporting
+
+## 2.1.24
+
+- feat: add MCP attachments and immediate chat delivery
+
 ## 2.1.23
 
 - feat: configure shutdown hooks and improve agent guidance

package/CONFIGURATION.md

@@ -397,14 +397,43 @@ silently.
 
 ### Hook environment variables
 
-Every hook gets the standard set: `WORKSPACE_ID`, `WORKSPACE_NAME`,
-`BRANCH_NAME`, `SOURCE_BRANCH`, `PROJECT_PATH`, plus `KOBO_HOOK_EVENT` naming
-the event. On top of that:
+Settings → Scripts and each project's script fields include expandable
+**Available variables** help. Setup, cleanup, archive and lifecycle scripts all
+run in the workspace worktree (`PWD`) and receive:
+
+| Variable | Value |
+|---|---|
+| `WORKSPACE_ID`, `WORKSPACE_NAME` | Workspace identifier and display name |
+| `BRANCH_NAME`, `SOURCE_BRANCH` | Working branch and source branch |
+| `PROJECT_PATH` | Main repository path, not the worktree |
+| `INSTANCE` | Matching Docker instance name, or the lowercased branch with `/` and `_` replaced by `-` |
+| `PROJECT_NAME` | Exact Compose project name from the matching `PROJECT_PATH/.container/instances/*.env` file; empty without a known matching instance |
+
+Docker identity is resolved at each script execution using the same instance
+metadata as the dev-server panel. It never inherits a Docker project from the
+server's environment or guesses one from a folder name. In particular, setup
+before the first dev-server launch usually has an empty `PROJECT_NAME`.
+Keep the metadata file if later archive/PR hooks need that identity. These
+variables are specific to the shared workspace script runner; dev start/stop
+and change-source-branch commands have their own contracts documented below.
+
+Quote variables and guard destructive Docker commands against a missing project:
+
+```bash
+# Archive or PR merged — stop this stack, preserving volumes and images.
+docker compose -p "${PROJECT_NAME:?Missing Docker project}" down --remove-orphans
+```
+
+Add `--volumes --rmi local` only to also remove its Compose-managed volumes and
+images without custom tags. This does not remove every image on the Docker host.
+
+Lifecycle hooks also receive `KOBO_HOOK_EVENT` naming the event. On top of that:
 
 | Hook | Extra variables |
 |---|---|
 | Session ended | `KOBO_SESSION_ID`, `KOBO_SESSION_END_REASON` (`completed` / `error` / `killed` / `watchdog`), `KOBO_SESSION_EXIT_CODE` (empty when the engine reports none), `KOBO_SESSION_STOP_CAUSE` (`user`, `replacement`, `setup`, `archive`, or `shutdown`; empty for a natural end; superseded sessions and delete/purge stops skip the hook), `KOBO_AUTOLOOP_ACTIVE` (`1` when auto-loop is enabled, so a test run may overlap with the next agent's edits) |
 | PR merged | `KOBO_PR_NUMBER`, `KOBO_PR_URL` |
+| Kōbō shutdown | `KOBO_SHUTDOWN_SIGNAL` |
 | Auto-loop stopped | `KOBO_AUTOLOOP_REASON` (`completed` / `user-action`; blocked missions retain their intent and do not fire this hook), `KOBO_TASKS_PENDING` |
 
 Only `KOBO_`-prefixed variables are passed through from the event; a hook
@@ -851,6 +880,13 @@ The setting lives in `settings.json` under `global` and has no UI control yet:
 
 An external MCP client can connect to `http://127.0.0.1:3000/api/mcp` using Streamable HTTP (use your backend's configured port). It can create workspaces with the same options as the form, diagnose and check out existing PRs, discover workspaces, read their conversations, send messages and answer pending questions. Workspace-bound stdio, global stdio and HTTP share the creation contract, including brainstorm settings, final auto-loop review, workflow policy, imports, existing worktrees, comparison grouping and inline attachments. All three transports also expose archive, disk-space purge, permanent deletion with explicit branch confirmation, unarchive and recovery of purged worktrees. See the [creation and PR guide](src/mcp-server/README.md#create_workspace) for fields, explicit checkout decisions and timeout/retry behavior.
 
+Both `create_workspace` and `send_workspace_message` accept inline `attachments`
+with `{name, mime_type, data_base64}`: 10 files, 50 MiB decoded total, same formats
+as the interface. Messages may contain only attachments. Kōbō saves them in the
+destination worktree and sends file/image references to the agent and chat.
+Keyed retries include attachment identity and never upload or send twice. See
+[Sending files and images](src/mcp-server/README.md#sending-files-and-images).
+
 Remote HTTP clients follow the [network access](#network-access) settings and supply the Kōbō token as `Authorization: Bearer <token>` or `X-Kobo-Token`. The endpoint uses the same Host/Origin and reverse-proxy policy as the rest of the backend. No network setting is changed automatically.
 
 See [Connect an external LLM](src/mcp-server/README.md#connect-an-external-llm) for connection examples, tool arguments, cursor polling and authentication details.
@@ -913,6 +949,20 @@ resume, not retroactively to an already running agent.
 
 The service retains at most 1,000 indicators per session, with at most 32 running
 at once. Hidden records are retained so retries cannot recreate dismissed bars.
+When a bar has no numeric total, the UI explicitly says **Progress not quantified**.
+After two minutes without a newer report it shows **No update for N min**. This
+is the age of the last received report, not proof that work stopped. The display
+clock does not poll the server or manufacture progress.
+
+Claude launches with progress tools also receive a bounded `PostToolUse` reminder:
+once on creation, then after at least eight subsequent tool completions and one
+minute without a report. Reminders are scoped to the producing agent/subagent,
+use the last observed sequence, and follow an explicit reporting handoff. They
+are advisory: no extra tool calls, automatic percentages or blocking stop hooks.
+Codex and external clients retain the shared MCP reporting guidance. Agents must
+supply measured counts when a real test total or fixed checklist is available;
+step-only updates correctly change the description without filling the gauge.
+
 The [MCP progress guide](src/mcp-server/README.md#session-progress-tools) documents
 arguments, ordering, retry behavior and update limits.
 
@@ -1425,6 +1475,23 @@ Kōbō talks to the embedded [`@anthropic-ai/claude-agent-sdk`](https://github.c
 
 The model selector is populated from [`src/shared/models.ts`](./src/shared/models.ts), also used by backend validation. This checkout includes Fable 5.1, Mythos 5, Opus 5, Opus 4.8, Sonnet 5 and older variants. Pick the default in **Settings → Agents**. Catalogue entries describe what Kōbō offers; provider access still depends on your account. `auto` leaves model selection to the runtime.
 
+#### Immediate chat messages
+
+**Settings → Agents → Force immediate message delivery** controls
+`forceImmediateMessages`, **false by default**, including existing installations.
+When enabled, new chat messages reach a busy Claude/Codex agent directly, like
+**Ctrl+Enter**, instead of waiting in Kōbō's message queue. Messages sent during
+an auto-loop go through immediate delivery and pause the active, ready loop.
+Previously queued instructions stay queued; changing the setting never sends
+old drafts automatically. The setting affects subsequent sends without restarting
+the server or agent.
+
+Compaction, pending questions/permissions, archive and session handoff guards
+still apply. Failed or rejected sends restore the draft; they do not silently
+queue it. MCP messages already use direct delivery and do not depend on this
+interface setting. Explicit next-iteration scheduling remains available through
+its dedicated auto-loop API.
+
 #### Session watchdogs
 
 **Settings → Agents → Enable agent inactivity watchdogs**, at the top of the tab,
@@ -1735,6 +1802,40 @@ Adapt the port stride, the `APP_NAME`, and any extra `*_PORT` keys to your stack
 
 Kōbō can open pull requests (GitHub or Bitbucket) or merge requests (GitLab) directly from the Git panel. The **forge** setting controls which service is used for a given project.
 
+### Review and edit a diff
+
+The diff viewer opens in **Inline** view. Use **Side by side** to change the layout.
+While an agent is working, **Edit** is disabled and its tooltip explains why;
+the diff remains readable and review comments remain available. The editor also
+becomes read-only if an agent starts while the diff is open. Stop the agent to
+resume editing. Server-side save checks remain in force.
+
+**Unpushed** compares the current working tree with `origin/<workingBranch>`:
+it includes local commits, staged and unstaged changes, deletions, and non-ignored
+untracked files. Before the first push, it uses the source branch instead. The
+header shows the comparison base. **Branch** retains its separate opt-in for
+untracked files. Comparing historical commits remains read-only.
+
+### Merge a pull request
+
+In the Git panel, **Merge PR** opens a confirmation. For GitHub, choose:
+
+- **Merge commit** (default): preserve the commits and create a merge commit.
+- **Squash and merge**: combine the changes into one commit on the target branch.
+- **Rebase and merge**: replay the commits on the target branch without a merge commit.
+
+The selection applies to this operation only. Kōbō rechecks PR readiness before
+calling the forge. Repository policies still apply: a disallowed method is
+reported as an error, with no automatic fallback or protection bypass. The
+source branch is kept; after a confirmed merge, remote deletion remains a
+separate confirmation. GitLab and Bitbucket retain their existing merge behavior.
+
+`POST /api/workspaces/:id/merge-pr` accepts optional JSON
+`{ "method": "merge" | "squash" | "rebase" }` for integrations advertising the
+corresponding `forge.capabilities.mergeMethods`. An omitted body keeps the
+existing provider default. Invalid values return 400; unsupported methods return
+409 before any merge command runs.
+
 ### Modes
 
 | Value | Behaviour |

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

@@ -3,9 +3,10 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getDb } from '../server/db/index.js';
+import { MAX_MCP_ATTACHMENT_REQUEST_BYTES } from '../shared/mcp-attachments.js';
 import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName, MEMORY_TOOL_DEFINITIONS } from '../shared/memory-tools.js';
 import { INTERNAL_PROGRESS_BAR_TOOLS, isProgressBarTool, PROGRESS_BAR_TOOLS } from '../shared/progress-bar-tools.js';
-import { isWorkspaceCreationTool, MAX_MCP_CREATION_REQUEST_BYTES, WORKSPACE_CREATION_TOOLS, } from '../shared/workspace-creation-tools.js';
+import { isWorkspaceCreationTool, WORKSPACE_CREATION_TOOLS } from '../shared/workspace-creation-tools.js';
 import { WORKSPACE_DIALOGUE_TOOLS } from '../shared/workspace-dialogue-tools.js';
 import { isWorkspaceGroupMessageTool, WORKSPACE_GROUP_MESSAGE_TOOLS } from '../shared/workspace-group-message-tools.js';
 import { isWorkspaceLifecycleTool, WORKSPACE_LIFECYCLE_TOOLS } from '../shared/workspace-lifecycle-tools.js';
@@ -1023,7 +1024,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 const transport = new StdioServerTransport(process.stdin, process.stdout, {
     // Include the JSON-lines delimiter in addition to the HTTP envelope budget.
-    maxBufferSize: MAX_MCP_CREATION_REQUEST_BYTES + 1,
+    maxBufferSize: MAX_MCP_ATTACHMENT_REQUEST_BYTES + 1,
 });
 server.connect(transport).catch((err) => {
     console.error('[kobo-tasks-server] Fatal:', err);

package/dist/server/routes/mcp.js

@@ -3,9 +3,10 @@ import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
+import { MAX_MCP_ATTACHMENT_REQUEST_BYTES } from '../../shared/mcp-attachments.js';
 import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName } from '../../shared/memory-tools.js';
 import { isProgressBarTool, PROGRESS_BAR_TOOLS } from '../../shared/progress-bar-tools.js';
-import { isWorkspaceCreationTool, MAX_MCP_CREATION_REQUEST_BYTES, WORKSPACE_CREATION_TOOLS, } from '../../shared/workspace-creation-tools.js';
+import { isWorkspaceCreationTool, WORKSPACE_CREATION_TOOLS } from '../../shared/workspace-creation-tools.js';
 import { EXTERNAL_MCP_TOOLS } from '../../shared/workspace-dialogue-tools.js';
 import { isWorkspaceGroupMessageTool, WORKSPACE_GROUP_MESSAGE_TOOLS, } from '../../shared/workspace-group-message-tools.js';
 import { isWorkspaceLifecycleTool, WORKSPACE_LIFECYCLE_TOOLS } from '../../shared/workspace-lifecycle-tools.js';
@@ -19,22 +20,27 @@ import { executeWorkspaceGroupMessageTool, WorkspaceGroupMessageMcpError, } from
 import { executeWorkspaceLifecycleTool, WorkspaceLifecycleMcpError, } from '../services/workspace-lifecycle-mcp-service.js';
 import { prepareMemoryToolEnvelope } from '../utils/memory-token-budget.js';
 const app = new Hono();
-// Only creation envelopes may carry the larger, base64 attachment payload.
+// Only creation and message envelopes may carry the larger, base64 attachment payload.
 // Other tools retain their existing 1 MiB limit, including malformed envelopes.
-app.use('*', bodyLimit({ maxSize: MAX_MCP_CREATION_REQUEST_BYTES }));
+app.use('*', bodyLimit({ maxSize: MAX_MCP_ATTACHMENT_REQUEST_BYTES }));
 app.use('*', async (c, next) => {
     if (c.req.raw.body) {
         const body = await c.req.raw.clone().arrayBuffer();
         if (body.byteLength > 1024 * 1024) {
-            let creation = false;
+            let attachmentTool = false;
             try {
                 const envelope = JSON.parse(new TextDecoder().decode(body));
-                creation = envelope?.method === 'tools/call' && envelope?.params?.name === 'create_workspace';
+                attachmentTool =
+                    envelope?.method === 'tools/call' &&
+                        (envelope?.params?.name === 'create_workspace' ||
+                            (envelope?.params?.name === 'send_workspace_message' &&
+                                Array.isArray(envelope?.params?.arguments?.attachments) &&
+                                envelope.params.arguments.attachments.length > 0));
             }
             catch {
                 /* Preserve the normal body-size rejection for malformed input. */
             }
-            if (!creation)
+            if (!attachmentTool)
                 return c.json({ error: 'MCP request is too large' }, 413);
         }
     }
@@ -64,7 +70,7 @@ app.all('/', async (c) => {
     const transport = new WebStandardStreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
         enableJsonResponse: true,
-        maxRequestBodySize: MAX_MCP_CREATION_REQUEST_BYTES,
+        maxRequestBodySize: MAX_MCP_ATTACHMENT_REQUEST_BYTES,
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [

package/dist/server/routes/workspaces.js

@@ -1,6 +1,7 @@
 import { execFile as execFileCb, execFileSync, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { nanoid } from 'nanoid';
+import { isMergeMethod } from '../../shared/forge-merge.js';
 import { isWorkflowPolicy, resolveWorkflowPolicy, WORKFLOW_ACTIONS, } from '../../shared/workflow-policy.js';
 import * as finalReviewService from '../services/auto-loop-final-review-service.js';
 import { getReviewReturnStatus } from '../services/review-return-service.js';
@@ -3483,15 +3484,14 @@ app.get('/:id/git-stats', async (c) => {
 //   `origin/<sourceBranch>` (which can be ahead of the local ref when
 //   upstream landed merges Kōbō hasn't pulled). The handler refreshes
 //   `origin/<sourceBranch>` synchronously so the diff is never stale.
-// - `unpushed`: committed-only changes vs `origin/<workingBranch>`,
-//   i.e. what the next `git push` will send.
+// - `unpushed`: local commits + current worktree changes (including untracked)
+//   vs `origin/<workingBranch>`, falling back to the source branch before the first push.
 app.get('/:id/diff', async (c) => {
     try {
         const id = c.req.param('id');
         const rawMode = c.req.query('mode');
         const mode = rawMode === 'unpushed' ? 'unpushed' : rawMode === 'commits' ? 'commits' : 'branch';
-        // Opt-in flag from the diff viewer toggle. Only meaningful in `branch`
-        // mode — `unpushed` is committed-only by definition.
+        // Branch mode keeps its untracked opt-in; unpushed always includes local untracked files.
         const includeUntracked = c.req.query('includeUntracked') === '1';
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
@@ -3525,7 +3525,7 @@ app.get('/:id/diff', async (c) => {
             await gitOps.fetchSourceBranchAsync(worktreePath, workspace.sourceBranch);
         }
         const files = mode === 'unpushed'
-            ? await gitOps.getUnpushedChangedFilesAsync(worktreePath, workspace.workingBranch)
+            ? await gitOps.getUnpushedChangedFilesAsync(worktreePath, workspace.workingBranch, 'origin', workspace.sourceBranch)
             : await gitOps.getChangedFilesAsync(worktreePath, workspace.sourceBranch, includeUntracked);
         c.header('Cache-Control', 'no-store');
         return c.json({
@@ -3533,6 +3533,11 @@ app.get('/:id/diff', async (c) => {
             mode,
             sourceBranch: workspace.sourceBranch,
             workingBranch: workspace.workingBranch,
+            ...(mode === 'unpushed'
+                ? {
+                    baseRef: await gitOps.resolveUnpushedBaseAsync(worktreePath, workspace.workingBranch, workspace.sourceBranch),
+                }
+                : {}),
         });
     }
     catch (err) {
@@ -3591,7 +3596,9 @@ app.get('/:id/diff-file', async (c) => {
                 to,
             });
         }
-        const baseRef = mode === 'unpushed' ? `origin/${workspace.workingBranch}` : workspace.sourceBranch;
+        const baseRef = mode === 'unpushed'
+            ? await gitOps.resolveUnpushedBaseAsync(worktreePath, workspace.workingBranch, workspace.sourceBranch)
+            : workspace.sourceBranch;
         const original = await gitOps.getFileAtRefAsync(worktreePath, baseRef, filePath);
         const modified = gitOps.getFileContent(worktreePath, filePath);
         c.header('Cache-Control', 'no-store');
@@ -4211,10 +4218,32 @@ app.post('/:id/merge-pr', async (c) => {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             return c.json({ error: `Workspace '${id}' not found` }, 404);
+        const rawBody = await c.req.text();
+        let body = {};
+        if (rawBody.length > 0) {
+            let parsed;
+            try {
+                parsed = JSON.parse(rawBody);
+            }
+            catch {
+                return c.json({ error: 'Request body must be valid JSON' }, 400);
+            }
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                return c.json({ error: 'Request body must be a JSON object' }, 400);
+            }
+            body = parsed;
+        }
+        const method = body.method;
+        if (method !== undefined && !isMergeMethod(method)) {
+            return c.json({ error: 'method must be merge, squash or rebase' }, 400);
+        }
         const provider = getForgeProvider(resolveForge(workspace.projectPath));
         if (!provider.capabilities.canMergeRequest) {
             return c.json({ error: 'This project has no forge that can merge the PR', code: 'forge_unsupported' }, 409);
         }
+        if (method !== undefined && !provider.capabilities.mergeMethods?.includes(method)) {
+            return c.json({ error: 'This forge does not support the requested merge method', code: 'merge_method_unsupported' }, 409);
+        }
         const availability = await provider.isAvailable(workspace.worktreePath);
         if (!availability.available) {
             return c.json({
@@ -4229,7 +4258,12 @@ app.post('/:id/merge-pr', async (c) => {
         if (!snapshot.readyToMerge) {
             return c.json({ error: 'This PR is not ready to merge', code: 'pr_not_ready' }, 409);
         }
-        await provider.mergeRequest(workspace.worktreePath, snapshot.number);
+        if (method === undefined) {
+            await provider.mergeRequest(workspace.worktreePath, snapshot.number);
+        }
+        else {
+            await provider.mergeRequest(workspace.worktreePath, snapshot.number, method);
+        }
         const merged = await provider.getPrStatus(workspace.worktreePath, workspace.workingBranch);
         return c.json({ success: true, merged: merged?.state === 'MERGED', branch: workspace.workingBranch });
     }

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

@@ -14,6 +14,7 @@ import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
 import { createMapperState, mapSdkMessage, QUOTA_PATTERN, tryEmitQuota } from './event-mapper.js';
 import { buildClaudeOptions } from './options-builder.js';
 import { buildCompactionSessionStartOutput } from './precompact-hook.js';
+import { createProgressReportingHook } from './progress-reporting-hook.js';
 import { resolveClaudeBinaryPath } from './resolve-binary.js';
 import { buildStopHookOutput } from './stop-hook.js';
 /**
@@ -341,6 +342,7 @@ export function createClaudeCodeEngine() {
             const hooks = {
                 ...(options.mcpServers?.some((server) => server.name === 'kobo-tasks' && server.env.KOBO_PROGRESS_SESSION_TOKEN)
                     ? {
+                        PostToolUse: [{ hooks: [createProgressReportingHook()] }],
                         SubagentStart: [
                             {
                                 hooks: [

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

@@ -0,0 +1,99 @@
+import { PROGRESS_MAX_RETAINED, PROGRESS_MAX_RUNNING } from '../../../../../shared/progress-bars.js';
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function progressResponse(value) {
+    if (typeof value === 'string') {
+        if (value.length > 16_384)
+            return null;
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    const result = object(value);
+    if (result?.isError === true)
+        return null;
+    if (result && object(result.structuredContent))
+        return object(result.structuredContent);
+    const blocks = Array.isArray(value) ? value : result?.content;
+    if (Array.isArray(blocks)) {
+        for (const entry of blocks.slice(0, 4)) {
+            const item = object(entry);
+            if (item?.type !== 'text' || typeof item.text !== 'string' || item.text.length > 16_384)
+                continue;
+            try {
+                return object(JSON.parse(item.text));
+            }
+            catch {
+                /* Not a JSON progress response. */
+            }
+        }
+        return null;
+    }
+    return result;
+}
+/** Per-launch advisory only: no timers, tool calls, writes or stop-blocking loops. */
+export function createProgressReportingHook() {
+    const bars = new Map();
+    const retired = new Set();
+    const reminder = (entries) => ({
+        hookSpecificOutput: {
+            hookEventName: 'PostToolUse',
+            additionalContext: `Kōbō progress reporting: keep these existing activities current at actual milestones. Next update arguments: ${entries.map(([id, state]) => JSON.stringify({ progress_id: id, sequence: state.sequence + 1 })).join('; ')}. Add step and measured current/total when known; otherwise report step only. Call update_progress_bar after meaningful work, and finish_progress_bar with the known outcome before your final report. Do not invent progress, poll, repeat unchanged updates, recreate dismissed bars or finish background work that is still running.`,
+        },
+    });
+    return async (input) => {
+        if (input.hook_event_name !== 'PostToolUse' || retired.size >= PROGRESS_MAX_RETAINED)
+            return {};
+        const producer = JSON.stringify([input.session_id, input.agent_id ?? null]);
+        const tool = input.tool_name;
+        if (/^mcp__kobo-tasks__(create|update|finish)_progress_bar$/.test(tool)) {
+            const bar = progressResponse(input.tool_response);
+            if (!bar ||
+                typeof bar.id !== 'string' ||
+                !/^[\w-]{1,200}$/.test(bar.id) ||
+                !Number.isSafeInteger(bar.sequence) ||
+                bar.sequence < 0 ||
+                !['running', 'succeeded', 'failed', 'interrupted'].includes(bar.status))
+                return {};
+            if (retired.has(bar.id))
+                return {};
+            const existing = bars.get(bar.id);
+            if (existing && bar.sequence < existing.sequence)
+                return {};
+            if (bar.dismissed === true || bar.status !== 'running') {
+                bars.delete(bar.id);
+                // Parallel hook results may arrive after completion; never resurrect a reporter.
+                retired.add(bar.id);
+                return {};
+            }
+            // A retry is not progress. A real update may hand reporting to a delegate.
+            if (existing && bar.sequence <= existing.sequence)
+                return {};
+            if (!existing && !tool.endsWith('create_progress_bar'))
+                return {};
+            if (!existing && bars.size >= PROGRESS_MAX_RUNNING)
+                return {};
+            const state = { producer, sequence: bar.sequence, actions: 0, remindedAt: Date.now() };
+            bars.set(bar.id, state);
+            return existing ? {} : reminder([[bar.id, state]]);
+        }
+        if (tool.startsWith('mcp__kobo-tasks__') && tool.endsWith('progress_bars'))
+            return {};
+        const due = [];
+        for (const [id, state] of bars) {
+            if (state.producer !== producer)
+                continue;
+            state.actions++;
+            if (state.actions >= 8 && Date.now() - state.remindedAt >= 60_000 && due.length < 3) {
+                state.actions = 0;
+                state.remindedAt = Date.now();
+                due.push([id, state]);
+            }
+        }
+        return due.length ? reminder(due) : {};
+    };
+}

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

@@ -1,10 +1,11 @@
 import { execFile, spawn } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { resolveInstance, sanitizeBranchName } from '../utils/dev-server-instance.js';
 import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
 import { getProjectSettings } from './settings-service.js';
 import { emitEphemeral } from './websocket-service.js';
 import { getWorkspace, listWorkspaces, updateDevServerStatus } from './workspace-service.js';
+export { parseEnvFile, resolveInstance, sanitizeBranchName } from '../utils/dev-server-instance.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
 /** Build a clean env for child processes, stripping Kobo-specific variables. */
 function cleanEnv() {
@@ -37,63 +38,6 @@ export function _resetTrackedProcessesForTests() {
     generations.clear();
     shuttingDown = false;
 }
-// ── Pure helpers ───────────────────────────────────────────────────────────────
-/**
- * Sanitize a branch name for use as a Docker instance name.
- * Replace `/` and `_` with `-`, lowercase.
- */
-export function sanitizeBranchName(branch) {
-    return branch.toLowerCase().replace(/[/_]/g, '-');
-}
-/**
- * Parse a `.env` file content into key=value pairs.
- * Skips empty lines and comments (#). Handles quotes.
- */
-export function parseEnvFile(content) {
-    const result = {};
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIndex = trimmed.indexOf('=');
-        if (eqIndex === -1)
-            continue;
-        const key = trimmed.slice(0, eqIndex).trim();
-        let value = trimmed.slice(eqIndex + 1).trim();
-        // Strip surrounding quotes
-        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
-}
-/**
- * Resolve the dev-server instance config for a given project + branch.
- * Looks in `<projectPath>/.container/instances/` for `.env` files.
- */
-export function resolveInstance(projectPath, workingBranch) {
-    const instancesDir = path.join(projectPath, '.container', 'instances');
-    if (!existsSync(instancesDir))
-        return null;
-    const sanitized = sanitizeBranchName(workingBranch);
-    const files = readdirSync(instancesDir).filter((f) => f.endsWith('.env'));
-    for (const file of files) {
-        const content = readFileSync(path.join(instancesDir, file), 'utf-8');
-        const parsed = parseEnvFile(content);
-        if (parsed.INSTANCE_NAME &&
-            parsed.INSTANCE_NAME.toLowerCase() === sanitized &&
-            parsed.PROJECT_NAME &&
-            /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(parsed.PROJECT_NAME)) {
-            return {
-                instanceName: parsed.INSTANCE_NAME,
-                projectName: parsed.PROJECT_NAME,
-                httpPort: parsed.HTTP_PORT ?? '',
-            };
-        }
-    }
-    return null;
-}
 // ── Docker helpers ─────────────────────────────────────────────────────────────
 /**
  * List all running Docker container names.

package/dist/server/services/forge/github/provider.js

@@ -1,6 +1,7 @@
 // src/server/services/forge/github/provider.ts
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { MERGE_METHODS } from '../../../../shared/forge-merge.js';
 import { parseCliJson } from '../parse-cli-json.js';
 import { deriveReadyToMerge, truncatePrBody } from '../types.js';
 const execFileAsync = promisify(execFile);
@@ -157,6 +158,7 @@ export const githubProvider = {
         canCreatePr: true,
         canChangePrBase: true,
         canMergeRequest: true,
+        mergeMethods: MERGE_METHODS,
         canDeleteRemoteBranch: true,
         canListPullRequests: true,
         requestTermShort: 'PR',
@@ -192,8 +194,8 @@ export const githubProvider = {
     async changePrBase(repoPath, base) {
         await execFileAsync('gh', ['pr', 'edit', '--base', base], cliOptions(repoPath));
     },
-    async mergeRequest(repoPath, number) {
-        await execFileAsync('gh', ['pr', 'merge', String(number), '--merge'], cliOptions(repoPath));
+    async mergeRequest(repoPath, number, method = 'merge') {
+        await execFileAsync('gh', ['pr', 'merge', String(number), `--${method}`], cliOptions(repoPath));
     },
     async deleteRemoteBranch(repoPath, branch) {
         await execFileAsync('git', ['push', 'origin', '--delete', branch], cliOptions(repoPath));