@loicngr/kobo 2.1.22 → 2.1.24

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() {
@@ -26,68 +27,16 @@ function runCommand(command, args, options = {}) {
 const trackedProcesses = new Map();
 const stoppingProcesses = new Map();
 const generations = new Map();
+let shuttingDown = false;
+export function beginDevServerShutdown() {
+    shuttingDown = true;
+}
 /** Test-only: clear the tracked-processes map between tests. */
 export function _resetTrackedProcessesForTests() {
     trackedProcesses.clear();
     stoppingProcesses.clear();
     generations.clear();
-}
-// ── 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;
+    shuttingDown = false;
 }
 // ── Docker helpers ─────────────────────────────────────────────────────────────
 /**
@@ -177,6 +126,8 @@ export async function getStatus(projectPath, workingBranch, workspaceId) {
  * Start the dev-server for a workspace.
  */
 export function startDevServer(workspaceId) {
+    if (shuttingDown)
+        throw new Error('Kōbō is shutting down');
     assertWorkspaceLifecycleAvailable(workspaceId);
     const workspace = getWorkspace(workspaceId);
     if (!workspace) {
@@ -231,7 +182,7 @@ export function startDevServer(workspaceId) {
                     return;
                 trackedProcesses.delete(workspaceId);
                 const currentStatus = await getStatus(workspace.projectPath, workspace.workingBranch);
-                if (generations.get(workspaceId) !== generation || stoppingProcesses.has(workspaceId))
+                if (shuttingDown || generations.get(workspaceId) !== generation || stoppingProcesses.has(workspaceId))
                     return;
                 updateDevServerStatus(workspaceId, currentStatus.status);
                 emitEphemeral(workspaceId, 'devserver:status', currentStatus);
@@ -244,7 +195,7 @@ export function startDevServer(workspaceId) {
             console.error(`[dev-server] Process exited with code ${code} for workspace ${workspaceId}`);
     });
     proc.on('error', (err) => {
-        if (trackedProcesses.get(workspaceId) !== proc)
+        if (shuttingDown || trackedProcesses.get(workspaceId) !== proc || generations.get(workspaceId) !== generation)
             return;
         // A signal failure is also an 'error' event; it does not prove process exit.
         if (!proc.pid)
@@ -373,6 +324,16 @@ function signalAndWait(proc, signal, timeoutMs) {
         }
     });
 }
+async function stopTrackedProcess(workspaceId) {
+    const tracked = trackedProcesses.get(workspaceId);
+    if (!tracked)
+        return;
+    const exited = (await signalAndWait(tracked, 'SIGTERM', 3_000)) || (await signalAndWait(tracked, 'SIGKILL', 1_000));
+    if (!exited)
+        throw new Error('Dev server stop is not confirmed; retry after the process exits');
+    if (trackedProcesses.get(workspaceId) === tracked)
+        trackedProcesses.delete(workspaceId);
+}
 async function stopDevServerOwned(workspaceId) {
     const workspace = getWorkspace(workspaceId);
     if (!workspace) {
@@ -383,14 +344,7 @@ async function stopDevServerOwned(workspaceId) {
     const worktreePath = workspace.worktreePath;
     const cwd = worktreePath && existsSync(worktreePath) ? worktreePath : workspace.projectPath;
     // Kill tracked process first (covers Node servers and any spawned process)
-    const tracked = trackedProcesses.get(workspaceId);
-    if (tracked) {
-        const exited = (await signalAndWait(tracked, 'SIGTERM', 3_000)) || (await signalAndWait(tracked, 'SIGKILL', 1_000));
-        if (!exited)
-            throw new Error('Dev server stop is not confirmed; retry after the process exits');
-        if (trackedProcesses.get(workspaceId) === tracked)
-            trackedProcesses.delete(workspaceId);
-    }
+    await stopTrackedProcess(workspaceId);
     const settings = getProjectSettings(workspace.projectPath);
     let stopError;
     let customStopSucceeded = false;
@@ -448,12 +402,30 @@ async function stopDevServerOwned(workspaceId) {
     emitEphemeral(workspaceId, 'devserver:status', status);
     return status;
 }
-/** Stop direct and Docker dev servers for every persisted workspace. */
-export async function stopAllDevServers() {
+/** Shut down local processes; optionally leave independently running Docker services alone. */
+export async function stopAllDevServers(options = {}) {
+    beginDevServerShutdown();
     const workspaceIds = new Set([...listWorkspaces(true).map((workspace) => workspace.id), ...trackedProcesses.keys()]);
     await Promise.all([...workspaceIds].map(async (workspaceId) => {
         try {
-            await stopDevServer(workspaceId);
+            if (!options.preserveDocker) {
+                await stopDevServer(workspaceId);
+            }
+            else {
+                // A stop already requested by the user must still finish.
+                const stopping = stoppingProcesses.get(workspaceId);
+                if (stopping) {
+                    await stopping;
+                    return;
+                }
+                const hadProcess = trackedProcesses.has(workspaceId);
+                await stopTrackedProcess(workspaceId);
+                const workspace = getWorkspace(workspaceId);
+                // Preserve Docker state; getStatus re-inspects Compose after restart.
+                if (hadProcess && workspace && !resolveInstance(workspace.projectPath, workspace.workingBranch)) {
+                    updateDevServerStatus(workspaceId, 'stopped');
+                }
+            }
         }
         catch (err) {
             console.error(`[dev-server] Failed to stop '${workspaceId}' during shutdown:`, err);

package/dist/server/services/lifecycle-hook-service.js

@@ -4,11 +4,14 @@ import { slugifyProjectName } from '../utils/project-slug.js';
 import { runScript } from '../utils/script-runner.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import { getEffectiveSettings, getGlobalSettings, getProjectSettings } from './settings-service.js';
+import { listWorkspaces } from './workspace-service.js';
+export const SHUTDOWN_SCRIPT_TIMEOUT_MS = 60_000;
 /** Which effective-settings key holds the script for each event. */
 const SCRIPT_KEY = {
     'session-ended': 'sessionEndedScript',
     'pr-merged': 'prMergedScript',
     'autoloop-disabled': 'autoLoopDisabledScript',
+    'kobo-shutdown': 'shutdownScript',
 };
 function getRow(workspaceId) {
     const row = getDb()
@@ -33,7 +36,7 @@ export async function runLifecycleHook(event, workspaceId, extraEnv) {
         const script = getEffectiveSettings(row.project_path)[SCRIPT_KEY[event]];
         // Empty (or blank) means the user never wrote one. Hooks are opt-in: they
         // run arbitrary shell, so absence of configuration is absence of a hook.
-        if (!script.trim())
+        if (!script?.trim())
             return null;
         const global = getGlobalSettings();
         const projectSettings = getProjectSettings(row.project_path);
@@ -55,10 +58,11 @@ export async function runLifecycleHook(event, workspaceId, extraEnv) {
             workspaceId,
             worktreePath,
             script,
-            // Namespaced per event: three hooks streaming into one `hook:output` feed
+            // Namespaced per event: multiple hooks streaming into one `hook:output` feed
             // would be indistinguishable in the UI.
             eventPrefix: `hook:${event}`,
             tmpFileName: `.hook-${event}.tmp`,
+            ...(event === 'kobo-shutdown' ? { timeoutMs: SHUTDOWN_SCRIPT_TIMEOUT_MS } : {}),
             env: {
                 workspaceName: row.name,
                 branchName: row.working_branch,
@@ -73,6 +77,21 @@ export async function runLifecycleHook(event, workspaceId, extraEnv) {
         return null;
     }
 }
+/** Called once by graceful shutdown, after stopping writers and before Docker teardown. */
+export async function onKoboShutdown(signal, isAgentStillRunning) {
+    await Promise.all(listWorkspaces(true)
+        .filter((workspace) => !workspace.worktreePurgedAt)
+        .map(async (workspace) => {
+        if (isAgentStillRunning(workspace.id)) {
+            console.warn(`[lifecycle-hook] 'kobo-shutdown' skipped for '${workspace.id}': agent stop unconfirmed`);
+            return;
+        }
+        const result = await runLifecycleHook('kobo-shutdown', workspace.id, { KOBO_SHUTDOWN_SIGNAL: signal });
+        if (result && result.exitCode !== 0) {
+            console.error(`[lifecycle-hook] 'kobo-shutdown' failed for '${workspace.id}' with code ${result.exitCode}`);
+        }
+    }));
+}
 /**
  * An agent session ended. Fires for every real end — clean finish, error, user
  * stop, watchdog kill — and lets the script tell them apart via

package/dist/server/services/mcp-message-delivery-service.js

@@ -4,7 +4,7 @@ import { broadcastPersistedEvent, persistWorkspaceEvent } from './websocket-serv
 import { deliverWorkspaceMessage } from './workspace-message-service.js';
 export async function deliverKeyedMcpMessage(workspaceId, key, message) {
     const db = getDb();
-    const request = reserveMessageRequest(db, workspaceId, key, message.content, message.sessionId);
+    const request = reserveMessageRequest(db, workspaceId, key, message.content, message.sessionId, message.attachments);
     if (!request.fresh)
         return request.result;
     let dispatched = false;

package/dist/server/services/mcp-message-request-service.js

@@ -1,9 +1,15 @@
 import { createHash } from 'node:crypto';
 import { nanoid } from 'nanoid';
-export function reserveMessageRequest(db, workspaceId, key, content, sessionId) {
-    const fingerprint = createHash('sha256')
-        .update(JSON.stringify([content, sessionId ?? null]))
-        .digest('hex');
+export function reserveMessageRequest(db, workspaceId, key, content, sessionId, attachments) {
+    // Keep text-only fingerprints compatible with receipts issued before attachment support.
+    const identity = [content, sessionId ?? null];
+    if (attachments?.length)
+        identity.push(attachments.map((file) => [
+            file.name,
+            file.mime_type,
+            createHash('sha256').update(file.data_base64).digest('hex'),
+        ]));
+    const fingerprint = createHash('sha256').update(JSON.stringify(identity)).digest('hex');
     return db
         .transaction(() => {
         const requestId = `mcp-${nanoid()}`;
@@ -23,7 +29,7 @@ export function reserveMessageRequest(db, workspaceId, key, content, sessionId)
                 accepted: false,
                 requestId: row.request_id,
                 code: 'idempotency_conflict',
-                message: 'This key was already used for different content or a different session',
+                message: 'This key was already used for different content, session or attachments',
             };
         else if (row.result_json) {
             result = JSON.parse(row.result_json);

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

@@ -996,6 +996,28 @@ const settingsMigrations = [
                 global.showProgressBars = true;
         },
     },
+    {
+        version: 66,
+        name: 'shutdown-services-and-hooks',
+        migrate: ({ global, projects }) => {
+            if (typeof global.stopDevServersOnShutdown !== 'boolean')
+                global.stopDevServersOnShutdown = true;
+            if (typeof global.shutdownScript !== 'string')
+                global.shutdownScript = '';
+            for (const project of projects) {
+                if (typeof project.shutdownScript !== 'string')
+                    project.shutdownScript = '';
+            }
+        },
+    },
+    {
+        version: 67,
+        name: 'opt-in-immediate-chat-messages',
+        migrate: ({ global }) => {
+            if (typeof global.forceImmediateMessages !== 'boolean')
+                global.forceImmediateMessages = false;
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -1044,6 +1066,7 @@ function defaultSettings() {
             archiveScript: '',
             changeSourceBranchScript: DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT,
             sessionEndedScript: '',
+            shutdownScript: '',
             prMergedScript: '',
             autoLoopDisabledScript: '',
             editorCommand: '',
@@ -1052,7 +1075,9 @@ function defaultSettings() {
             autoPurgeOnPrMerged: false,
             autoLoopMaxRetries: 5,
             agentWatchdogEnabled: false,
+            forceImmediateMessages: false,
             showProgressBars: true,
+            stopDevServersOnShutdown: true,
             awaitingUserReminderMinutes: 0,
             activityDigestEnabled: true,
             maxConcurrentAgents: 2,
@@ -1156,6 +1181,7 @@ function defaultProjectSettings(projectPath) {
         archiveScript: '',
         changeSourceBranchScript: '',
         sessionEndedScript: '',
+        shutdownScript: '',
         prMergedScript: '',
         autoLoopDisabledScript: '',
         devServer: {
@@ -1201,11 +1227,19 @@ export function runSettingsMigrations(raw) {
     current.global.workflowPolicy = resolveWorkflowPolicy(current.global.workflowPolicy);
     if (!isMemoryMode(current.global.memoryMode))
         current.global.memoryMode = 'hybrid';
+    if (typeof current.global.forceImmediateMessages !== 'boolean')
+        current.global.forceImmediateMessages = false;
     if (typeof current.global.showProgressBars !== 'boolean')
         current.global.showProgressBars = true;
+    if (typeof current.global.stopDevServersOnShutdown !== 'boolean')
+        current.global.stopDevServersOnShutdown = true;
+    if (typeof current.global.shutdownScript !== 'string')
+        current.global.shutdownScript = '';
     if (typeof current.global.agentWatchdogEnabled !== 'boolean')
         current.global.agentWatchdogEnabled = false;
     for (const project of current.projects) {
+        if (typeof project.shutdownScript !== 'string')
+            project.shutdownScript = '';
         if (!isWorkflowPolicy(project.workflowPolicy))
             project.workflowPolicy = {};
     }
@@ -1478,6 +1512,7 @@ export function getEffectiveSettings(projectPath) {
             archiveScript: settings.global.archiveScript,
             changeSourceBranchScript: settings.global.changeSourceBranchScript,
             sessionEndedScript: settings.global.sessionEndedScript,
+            shutdownScript: settings.global.shutdownScript,
             prMergedScript: settings.global.prMergedScript,
             autoLoopDisabledScript: settings.global.autoLoopDisabledScript,
             notionStatusProperty: settings.global.notionStatusProperty,
@@ -1508,6 +1543,7 @@ export function getEffectiveSettings(projectPath) {
         archiveScript: project.archiveScript || settings.global.archiveScript,
         changeSourceBranchScript: project.changeSourceBranchScript || settings.global.changeSourceBranchScript,
         sessionEndedScript: project.sessionEndedScript || settings.global.sessionEndedScript,
+        shutdownScript: project.shutdownScript || settings.global.shutdownScript,
         prMergedScript: project.prMergedScript || settings.global.prMergedScript,
         autoLoopDisabledScript: project.autoLoopDisabledScript || settings.global.autoLoopDisabledScript,
         notionStatusProperty: settings.global.notionStatusProperty,
@@ -1557,6 +1593,15 @@ export function updateGlobalSettings(input) {
             delete data.autoLoopMaxRetries;
         }
     }
+    if ('shutdownScript' in data && typeof data.shutdownScript !== 'string') {
+        delete data.shutdownScript;
+    }
+    if ('stopDevServersOnShutdown' in data && typeof data.stopDevServersOnShutdown !== 'boolean') {
+        delete data.stopDevServersOnShutdown;
+    }
+    if ('forceImmediateMessages' in data && typeof data.forceImmediateMessages !== 'boolean') {
+        delete data.forceImmediateMessages;
+    }
     if ('showProgressBars' in data && typeof data.showProgressBars !== 'boolean') {
         delete data.showProgressBars;
     }
@@ -1619,6 +1664,7 @@ export function updateGlobalSettings(input) {
         'archiveScript',
         'changeSourceBranchScript',
         'sessionEndedScript',
+        'shutdownScript',
         'prMergedScript',
         'autoLoopDisabledScript',
         'editorCommand',
@@ -1627,7 +1673,9 @@ export function updateGlobalSettings(input) {
         'autoPurgeOnPrMerged',
         'autoLoopMaxRetries',
         'agentWatchdogEnabled',
+        'forceImmediateMessages',
         'showProgressBars',
+        'stopDevServersOnShutdown',
         'awaitingUserReminderMinutes',
         'activityDigestEnabled',
         'maxConcurrentAgents',
@@ -1823,6 +1871,8 @@ export function upsertProject(projectPath, data) {
     }
     if ('workflowPolicy' in data && !isWorkflowPolicy(data.workflowPolicy))
         throw new Error('Invalid workflowPolicy');
+    if ('shutdownScript' in data && typeof data.shutdownScript !== 'string')
+        throw new Error('Invalid shutdownScript');
     const allowedProjectKeys = [
         'workflowPolicy',
         'displayName',
@@ -1842,6 +1892,7 @@ export function upsertProject(projectPath, data) {
         'archiveScript',
         'changeSourceBranchScript',
         'sessionEndedScript',
+        'shutdownScript',
         'prMergedScript',
         'autoLoopDisabledScript',
         'devServer',

package/dist/server/services/workspace-dialogue-service.js

@@ -85,6 +85,7 @@ export async function executeWorkspaceDialogueTool(name, input, source = createM
     if (name === 'send_workspace_message' && args.idempotency_key)
         return deliverKeyedMcpMessage(workspaceId, args.idempotency_key, {
             content: args.content,
+            ...(args.attachments ? { attachments: args.attachments } : {}),
             sessionId: args.session_id,
             source,
         });
@@ -93,6 +94,7 @@ export async function executeWorkspaceDialogueTool(name, input, source = createM
             accepted: true,
             ...(await deliverWorkspaceMessage(workspaceId, {
                 content: args.content,
+                ...(args.attachments ? { attachments: args.attachments } : {}),
                 sessionId: args.session_id,
                 clientMessageId: `mcp-${nanoid()}`,
                 source,

package/dist/server/services/workspace-message-service.js

@@ -1,5 +1,7 @@
-import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { validateMcpAttachments } from '../../shared/mcp-attachments.js';
+import { assertWorkspaceLifecycleAvailable, withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
 import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import { attachmentReference, removeAttachments, saveAttachments } from './attachment-service.js';
 import { hasLoopMessage } from './auto-loop-message-service.js';
 import * as autoLoop from './auto-loop-service.js';
 import { createChatReceipt } from './chat-receipt-service.js';
@@ -7,10 +9,28 @@ import { emitEphemeral } from './websocket-service.js';
 import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './workspace-service.js';
 /** Shared delivery for WebSocket chat and external MCP clients. */
 export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
+    // Keep the caller's original content unchanged for durable idempotency fingerprints.
+    message = { ...message };
     const receipt = createChatReceipt(workspaceId, message, hooks?.persist);
+    let saved = [];
+    let attachmentWorktree;
+    let dispatched = false;
+    const beforeDispatch = () => {
+        if (saved.length) {
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            const current = getWorkspace(workspaceId);
+            if (!current || current.archivedAt || current.worktreePurgedAt || current.worktreePath !== attachmentWorktree)
+                throw new Error('Workspace changed before attachment delivery');
+            if (current.status === 'compacting' || current.status === 'awaiting-user' || isShuttingDown())
+                throw new Error('Workspace is not ready to receive a message');
+        }
+        hooks?.beforeDispatch?.();
+        dispatched = true;
+    };
     let reason;
     try {
-        if (!message.content.trim())
+        const attachments = validateMcpAttachments(message.attachments);
+        if (!message.content.trim() && !attachments.length)
             throw new Error('Message content must not be empty');
         if (isShuttingDown())
             throw new Error('Kōbō is shutting down');
@@ -21,6 +41,8 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
         if (workspace.archivedAt || workspace.worktreePurgedAt)
             throw new Error('Restore the workspace before sending a message');
         if (message.delivery === 'next_iteration') {
+            if (attachments.length)
+                throw new Error('Attachments require immediate delivery');
             if (!message.clientMessageId)
                 throw new Error('clientMessageId is required for queued delivery');
             const acceptedBefore = hasLoopMessage(workspaceId, message.clientMessageId);
@@ -45,11 +67,28 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             reason = 'awaiting-user';
             throw new Error('Answer the pending question or permission request before sending a chat message');
         }
+        if (attachments.length) {
+            attachmentWorktree = workspace.worktreePath;
+            await withWorkspaceLifecycleGuard(workspaceId, async () => {
+                const files = attachments.map((file) => new File([Buffer.from(file.data_base64, 'base64')], file.name, { type: file.mime_type }));
+                saved = await saveAttachments(workspace.worktreePath, files);
+            });
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            const current = getWorkspace(workspaceId);
+            if (!current || current.archivedAt || current.worktreePurgedAt || current.worktreePath !== attachmentWorktree)
+                throw new Error('Workspace changed while saving attachments');
+            if (current.status === 'compacting' || current.status === 'awaiting-user' || isShuttingDown())
+                throw new Error('Workspace is not ready to receive a message');
+            message.content = [message.content.trim(), ...saved.map(attachmentReference)].filter(Boolean).join('\n\n');
+            // Binary data never belongs in the chat receipt or agent prompt.
+            delete message.attachments;
+        }
+        const trackDispatch = !!hooks?.beforeDispatch || saved.length > 0;
         const loop = autoLoop.getStatus(workspaceId);
         let sessionId = message.sessionId ?? getActiveSession(workspaceId)?.id;
         try {
-            if (hooks?.beforeDispatch)
-                await sendMessage(workspaceId, message.content, message.sessionId, hooks.beforeDispatch);
+            if (trackDispatch)
+                await sendMessage(workspaceId, message.content, message.sessionId, beforeDispatch);
             else
                 await sendMessage(workspaceId, message.content, message.sessionId);
         }
@@ -61,7 +100,7 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             const current = getWorkspace(workspaceId);
             if (!current || current.archivedAt || current.worktreePurgedAt)
                 throw new Error('Workspace is unavailable');
-            const started = startAgent(workspaceId, current.worktreePath, message.content, current.model, true, message.agentPermissionModeOverride ?? current.agentPermissionMode, message.sessionId, current.reasoningEffort, ...(hooks?.beforeDispatch ? [hooks.beforeDispatch] : []));
+            const started = startAgent(workspaceId, current.worktreePath, message.content, current.model, true, message.agentPermissionModeOverride ?? current.agentPermissionMode, message.sessionId, current.reasoningEffort, ...(trackDispatch ? [beforeDispatch] : []));
             updateWorkspaceStatus(workspaceId, 'executing');
             sessionId = message.sessionId ?? started.agentSessionId;
         }
@@ -71,6 +110,23 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
         return { sessionId };
     }
     catch (error) {
+        // Once dispatch may have happened, keep files available to the agent even if
+        // acknowledgement failed. Only remove files from a definitively rejected send.
+        if (saved.length && attachmentWorktree && !dispatched) {
+            const worktree = attachmentWorktree;
+            try {
+                await withWorkspaceLifecycleGuard(workspaceId, async () => {
+                    const current = getWorkspace(workspaceId);
+                    if (!current || current.worktreePurgedAt || current.worktreePath !== worktree)
+                        return;
+                    for (const warning of await removeAttachments(worktree, saved))
+                        console.warn(`[message-attachments] ${warning}`);
+                });
+            }
+            catch {
+                // A competing lifecycle operation owns the checkout now; do not touch it.
+            }
+        }
         receipt.reject(error instanceof Error ? error.message : String(error), reason);
         throw error;
     }

package/dist/server/utils/dev-server-instance.js

@@ -0,0 +1,58 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * 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;
+}

package/dist/server/utils/script-runner.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as wsService from '../services/websocket-service.js';
+import { resolveInstance, sanitizeBranchName } from './dev-server-instance.js';
 import { getIndexLockPath } from './git-ops.js';
 import { ensureDirectoryInside } from './safe-path.js';
 /** Default wall-clock budget for a user script before it is force-killed. */
@@ -39,6 +40,8 @@ export function runScript(opts) {
         scriptDirectory = fs.mkdtempSync(path.join(storage, '.script-'));
         scriptPath = path.join(scriptDirectory, path.basename(tmpFileName));
         fs.writeFileSync(scriptPath, script, { mode: 0o700, flag: 'wx' });
+        // Resolve only from this workspace's persisted instance, never the host's env.
+        const instance = env?.projectPath && env.branchName ? resolveInstance(env.projectPath, env.branchName) : null;
         const proc = spawn('bash', [scriptPath], {
             cwd: worktreePath,
             env: {
@@ -49,6 +52,8 @@ export function runScript(opts) {
                 BRANCH_NAME: env?.branchName ?? '',
                 SOURCE_BRANCH: env?.sourceBranch ?? '',
                 PROJECT_PATH: env?.projectPath ?? '',
+                PROJECT_NAME: instance?.projectName ?? '',
+                INSTANCE: instance?.instanceName ?? sanitizeBranchName(env?.branchName ?? ''),
             },
             stdio: ['ignore', 'pipe', 'pipe'],
             // Detached so this is the leader of its own process group: a script
@@ -74,7 +79,7 @@ export function runScript(opts) {
             proc.stdout?.destroy();
             proc.stderr?.destroy();
             wsService.emit(workspaceId, `${eventPrefix}:output`, {
-                text: `[kobo] Script timed out after ${Math.round(timeoutMs / 60000)} minutes`,
+                text: `[kobo] Script timed out after ${timeoutMs < 60000 ? `${Math.round(timeoutMs / 1000)} seconds` : `${Math.round(timeoutMs / 60000)} minutes`}`,
             });
             // SIGKILL on the process group gives a running `git commit` no chance to
             // release its index lock. Name the file here, while the user is looking