@bbigbang/core 0.1.0

package/dist/services/workspaceScaffold.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function buildRoleScaffoldLine(agentName) {
+    const normalizedAgentName = agentName
+        ?.replace(/[\r\n]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalizedAgentName)
+        return '- Capture your current role and responsibilities here.';
+    return `- you are ${normalizedAgentName}. Capture your current role and responsibilities here.`;
+}
+const BEIJING_DATE_FORMATTER = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Asia/Shanghai',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+});
+function getCurrentBeijingISOWeek() {
+    const parts = BEIJING_DATE_FORMATTER.formatToParts(new Date());
+    const getPart = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const year = getPart('year');
+    const month = getPart('month');
+    const day = getPart('day');
+    const beijingDate = new Date(Date.UTC(year, month - 1, day));
+    const dayNum = beijingDate.getUTCDay() || 7;
+    beijingDate.setUTCDate(beijingDate.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(beijingDate.getUTCFullYear(), 0, 1));
+    const weekNo = Math.ceil((((beijingDate.getTime() - yearStart.getTime()) / 86_400_000) + 1) / 7);
+    return `${beijingDate.getUTCFullYear()}-W${String(weekNo).padStart(2, '0')}`;
+}
+/** One-time migration: move legacy flat work-log to the weekly directory structure. */
+export function migrateLocalWorkspaceLegacyFiles(workspaceRoot) {
+    const legacyWorkLogPath = path.join(workspaceRoot, 'notes', 'work-log.md');
+    const legacyDestPath = path.join(workspaceRoot, 'notes', 'work-log', 'legacy.md');
+    if (!fs.existsSync(legacyWorkLogPath))
+        return;
+    if (!fs.existsSync(legacyDestPath)) {
+        fs.renameSync(legacyWorkLogPath, legacyDestPath);
+    }
+    else {
+        const orphan = fs.readFileSync(legacyWorkLogPath, 'utf8').trim();
+        if (orphan) {
+            fs.appendFileSync(legacyDestPath, `\n\n<!-- re-migrated -->\n${orphan}\n`, 'utf8');
+        }
+        fs.rmSync(legacyWorkLogPath);
+    }
+}
+export function ensureLocalWorkspaceScaffold(workspaceRoot, agentName) {
+    fs.mkdirSync(workspaceRoot, { recursive: true });
+    fs.mkdirSync(path.join(workspaceRoot, 'notes'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceRoot, 'notes', 'channels'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceRoot, 'notes', 'work-log'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceRoot, 'notes', 'archive'), { recursive: true });
+    migrateLocalWorkspaceLegacyFiles(workspaceRoot);
+    const taskNotesPath = path.join(workspaceRoot, 'notes', 'tasks.md');
+    if (!fs.existsSync(taskNotesPath)) {
+        fs.writeFileSync(taskNotesPath, [
+            '# Task Notes',
+            '',
+            'Active tasks only (todo / in_progress / in_review). Remove a task here when it is done and archive it.',
+            '',
+        ].join('\n'), 'utf8');
+    }
+    const archiveIndexPath = path.join(workspaceRoot, 'notes', 'archive', 'INDEX.md');
+    if (!fs.existsSync(archiveIndexPath)) {
+        fs.writeFileSync(archiveIndexPath, [
+            '# Archive Index',
+            '',
+            'One line per week: YYYY-Www: <task title> — <one-line result>',
+            '',
+        ].join('\n'), 'utf8');
+    }
+    const currentWeek = getCurrentBeijingISOWeek();
+    const currentWorkLogPath = path.join(workspaceRoot, 'notes', 'work-log', `${currentWeek}.md`);
+    if (!fs.existsSync(currentWorkLogPath)) {
+        fs.writeFileSync(currentWorkLogPath, [
+            `# Work Log ${currentWeek}`,
+            '',
+            'Append key decisions, completed work, and follow-ups for this Beijing week here.',
+            '',
+        ].join('\n'), 'utf8');
+    }
+    const memoryPath = path.join(workspaceRoot, 'MEMORY.md');
+    if (!fs.existsSync(memoryPath)) {
+        fs.writeFileSync(memoryPath, [
+            '# Memory',
+            '',
+            '## Role',
+            buildRoleScaffoldLine(agentName),
+            '',
+            '## Key Knowledge',
+            '- Read `notes/user-preferences.md` for stable user preferences and conventions.',
+            '- Read `notes/channels/<name>.md` for each channel\'s current purpose and active context.',
+            '- Read `notes/tasks.md` for active tasks only (todo / in_progress / in_review).',
+            '- Weekly work log in `notes/work-log/`. Read the current week\'s file for recent decisions; if `notes/work-log/legacy.md` exists, scan it for pre-migration history when older decisions may matter.',
+            '- Completed task archive in `notes/archive/`. Scan `notes/archive/INDEX.md` to locate a specific week.',
+            '- Shared documents, when available, are mounted at `.library/shared`. Before modifying them, read `.library/shared/README.txt`.',
+            '- Add topic-specific knowledge under `notes/<topic>.md` as needed.',
+            '',
+            '## Active Context',
+            '- First startup.',
+            '',
+        ].join('\n'), 'utf8');
+    }
+}

package/dist/services/workspaceSessionRuntimeService.js

@@ -0,0 +1,576 @@
+import { randomUUID } from 'node:crypto';
+import { getRuntimeDriver } from '@bbigbang/protocol';
+import { createRun, finishRun, log } from '@bbigbang/runtime-acp';
+import { WorkspaceSessionServiceError, } from './workspaceSessionService.js';
+import { getWorkspaceRunDispatchNodeId, getWorkspaceSessionOwnerNodeId, persistWorkspaceRunDispatchContext, } from './workspaceRunOwnership.js';
+const WORKSPACE_APPROVAL_RESPONSE_SENT_METHOD = 'approval/response.sent';
+const WORKSPACE_APPROVAL_PROGRESS_TYPES_SQL = [
+    "'content.delta'",
+    "'thinking.delta'",
+    "'tool.call'",
+    "'tool.result'",
+    "'plan.update'",
+    "'plan.phase'",
+    "'task.update'",
+    "'runtime.compact'",
+].join(', ');
+export class WorkspaceSessionRuntimeService {
+    db;
+    nodeRegistry;
+    workspaceSessionService;
+    nodeDispatchAckTimeoutMs;
+    pendingDispatchAcceptances = new Map();
+    constructor(params) {
+        this.db = params.db;
+        this.nodeRegistry = params.nodeRegistry;
+        this.workspaceSessionService = params.workspaceSessionService;
+        this.nodeDispatchAckTimeoutMs = params.nodeDispatchAckTimeoutMs;
+    }
+    async submitPrompt(params) {
+        const promptText = normalizePromptText(params.text);
+        const context = this.workspaceSessionService.getRuntimeContext({
+            workspaceSessionId: params.workspaceSessionId,
+            user: params.user,
+            canAccessAgent: params.canAccessAgent,
+        });
+        if (context.session.archivedAt != null) {
+            throw new WorkspaceSessionServiceError(409, 'Archived workspace sessions cannot dispatch prompts.');
+        }
+        const nodeId = getWorkspaceSessionOwnerNodeId(this.db, context.sessionKey)
+            ?? context.root.nodeId
+            ?? context.agent.nodeId
+            ?? null;
+        if (!nodeId) {
+            throw new WorkspaceSessionServiceError(409, 'No agent node assigned for this workspace session.');
+        }
+        const runId = randomUUID();
+        const hostKey = `workspace_session:${context.session.workspaceSessionId}:${context.agent.agentType}`;
+        const dispatchMode = this.getDispatchMode(context.sessionKey);
+        const queued = this.hasOpenRun(context.sessionKey);
+        const driver = getRuntimeDriver(context.agent.agentType);
+        const runtimeOverrides = normalizePromptRuntimeOverrides(params.runtimeOverrides);
+        const systemPromptText = buildWorkspaceSessionSystemPrompt(context.agent, context.root.rootPath);
+        const contextText = buildWorkspaceSessionContextText(context.session.workspaceSessionId, context.root.rootPath);
+        updateSessionCwd(this.db, context.sessionKey, context.root.rootPath);
+        createRun(this.db, { runId, sessionKey: context.sessionKey, promptText });
+        persistWorkspaceRunDispatchContext(this.db, runId, {
+            nodeId,
+            workspaceSessionId: context.session.workspaceSessionId,
+            agentId: context.agent.agentId,
+            workspaceRootId: context.session.workspaceRootId,
+        });
+        const session = this.workspaceSessionService.updateSessionStatus(context.session.workspaceSessionId, this.getStatusAfterDispatchStart(context.sessionKey, queued), { touchLastActive: true }) ?? context.session;
+        const node = this.nodeRegistry.getNode(nodeId);
+        if (!node) {
+            this.finishDispatchFailure({
+                runId,
+                error: 'Node not connected',
+                workspaceSessionId: context.session.workspaceSessionId,
+                sessionKey: context.sessionKey,
+                previousStatus: context.session.status,
+            });
+            log.warn('[workspace-session-runtime] node not connected', {
+                nodeId,
+                workspaceSessionId: context.session.workspaceSessionId,
+                runId,
+            });
+            throw new WorkspaceSessionServiceError(409, `Node not connected: ${nodeId}`);
+        }
+        if (!node.agentTypes.includes(context.agent.agentType)) {
+            const errorMessage = `Node does not support agent type ${context.agent.agentType}`;
+            this.finishDispatchFailure({
+                runId,
+                error: errorMessage,
+                workspaceSessionId: context.session.workspaceSessionId,
+                sessionKey: context.sessionKey,
+                previousStatus: context.session.status,
+            });
+            throw new WorkspaceSessionServiceError(409, `${errorMessage}: ${nodeId}`);
+        }
+        const acceptance = this.waitForDispatchAcceptance(runId, nodeId, context.session.workspaceSessionId, context.sessionKey);
+        const dispatchSent = this.nodeRegistry.send(nodeId, {
+            type: 'run.dispatch',
+            runId,
+            conversationId: context.session.workspaceSessionId,
+            agentType: context.agent.agentType,
+            ...(context.agent.model ? { model: context.agent.model } : {}),
+            ...(context.agent.reasoningEffort ? { reasoningEffort: context.agent.reasoningEffort } : {}),
+            ...(context.agent.agentType === 'codex_app_server' && runtimeOverrides?.codexMode ? { codexMode: runtimeOverrides.codexMode } : {}),
+            ...(context.agent.agentType === 'codex_app_server' && context.agent.codexServiceTier ? { codexServiceTier: context.agent.codexServiceTier } : {}),
+            workspacePath: context.root.rootPath,
+            agentName: context.agent.name,
+            ...(context.agent.skillRoots ? { skillRoots: context.agent.skillRoots } : {}),
+            envVars: {
+                ...(context.agent.envVars ?? {}),
+                ...(driver.defaultEnv ?? {}),
+            },
+            disabledToolKinds: context.agent.disabledToolKinds,
+            prompt: promptText,
+            ...(runtimeOverrides ? { runtimeOverrides } : {}),
+            sessionKey: context.sessionKey,
+            hostKey,
+            dispatchMode,
+            systemPromptText,
+            contextText,
+        });
+        if (!dispatchSent) {
+            this.clearPendingDispatchAcceptance(runId);
+            this.finishDispatchFailure({
+                runId,
+                error: 'Node disconnected during dispatch',
+                workspaceSessionId: context.session.workspaceSessionId,
+                sessionKey: context.sessionKey,
+                previousStatus: context.session.status,
+            });
+            throw new WorkspaceSessionServiceError(409, `Node disconnected: ${nodeId}`);
+        }
+        try {
+            await acceptance;
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            this.finishDispatchFailure({
+                runId,
+                error: message,
+                workspaceSessionId: context.session.workspaceSessionId,
+                sessionKey: context.sessionKey,
+                previousStatus: context.session.status,
+            });
+            throw new WorkspaceSessionServiceError(409, message);
+        }
+        log.info('[workspace-session-runtime] dispatching prompt', {
+            nodeId,
+            workspaceSessionId: context.session.workspaceSessionId,
+            runId,
+            dispatchMode,
+            hostKey,
+        });
+        return {
+            queued,
+            runId,
+            dispatchMode,
+            session: this.workspaceSessionService.updateSessionStatus(context.session.workspaceSessionId, this.hasOpenPendingApproval(context.sessionKey) ? 'awaiting_approval' : 'active', { touchLastActive: true }) ?? session,
+        };
+    }
+    respondToApproval(params) {
+        const context = this.workspaceSessionService.getRuntimeContext({
+            workspaceSessionId: params.workspaceSessionId,
+            user: params.user,
+            canAccessAgent: params.canAccessAgent,
+        });
+        if (context.session.archivedAt != null) {
+            throw new WorkspaceSessionServiceError(409, 'Archived workspace sessions cannot answer approvals.');
+        }
+        const requestId = normalizeRequiredString(params.request?.requestId, 'Approval request id is required.');
+        const decision = normalizeApprovalDecision(params.request?.decision);
+        const selectedActionId = normalizeOptionalString(params.request?.selectedActionId);
+        const responseText = normalizeOptionalString(params.request?.responseText);
+        const runId = findPendingApprovalRunId(this.db, context.sessionKey, requestId);
+        if (!runId) {
+            throw new WorkspaceSessionServiceError(409, 'No pending approval request found for this workspace session.');
+        }
+        const nodeId = getWorkspaceRunDispatchNodeId(this.db, runId);
+        if (!nodeId) {
+            throw new WorkspaceSessionServiceError(409, 'Workspace run owner is not recorded for this approval request.');
+        }
+        const sent = this.nodeRegistry.send(nodeId, {
+            type: 'permission.response',
+            requestId,
+            decision,
+            ...(selectedActionId ? { selectedActionId } : {}),
+            ...(responseText ? { responseText } : {}),
+        });
+        if (!sent) {
+            throw new WorkspaceSessionServiceError(409, `Node not connected: ${nodeId}`);
+        }
+        persistApprovalResponseSentMarker(this.db, runId, requestId, decision, selectedActionId, responseText);
+        const session = this.workspaceSessionService.updateSessionStatus(context.session.workspaceSessionId, this.hasOpenPendingApproval(context.sessionKey) ? 'awaiting_approval' : 'active', { touchLastActive: true }) ?? context.session;
+        return { ok: true, session };
+    }
+    cancelCurrentRun(params) {
+        const context = this.workspaceSessionService.getRuntimeContext({
+            workspaceSessionId: params.workspaceSessionId,
+            user: params.user,
+            canAccessAgent: params.canAccessAgent,
+        });
+        if (context.session.archivedAt != null) {
+            throw new WorkspaceSessionServiceError(409, 'Archived workspace sessions cannot cancel runs.');
+        }
+        const runId = this.getCurrentOpenRunId(context.sessionKey);
+        if (!runId) {
+            throw new WorkspaceSessionServiceError(409, 'No active workspace run to cancel.');
+        }
+        const nodeId = getWorkspaceRunDispatchNodeId(this.db, runId);
+        if (!nodeId) {
+            throw new WorkspaceSessionServiceError(409, 'Workspace run owner is not recorded for this run.');
+        }
+        const sent = this.nodeRegistry.send(nodeId, {
+            type: 'run.cancel',
+            runId,
+        });
+        if (!sent) {
+            throw new WorkspaceSessionServiceError(409, `Node not connected: ${nodeId}`);
+        }
+        const session = this.workspaceSessionService.updateSessionStatus(context.session.workspaceSessionId, context.session.status, { touchLastActive: true }) ?? context.session;
+        return { ok: true, runId, session };
+    }
+    listEvents(params) {
+        const context = this.workspaceSessionService.getRuntimeContext({
+            workspaceSessionId: params.workspaceSessionId,
+            user: params.user,
+            canAccessAgent: params.canAccessAgent,
+        });
+        return {
+            session: context.session,
+            events: listWorkspaceSessionEvents(this.db, context.sessionKey),
+        };
+    }
+    handleRunAccepted(runId) {
+        const pending = this.pendingDispatchAcceptances.get(runId);
+        if (!pending)
+            return false;
+        clearTimeout(pending.timer);
+        this.pendingDispatchAcceptances.delete(runId);
+        this.workspaceSessionService.updateSessionStatus(pending.workspaceSessionId, this.hasOpenPendingApproval(pending.sessionKey) ? 'awaiting_approval' : 'active', { touchLastActive: true });
+        pending.resolve();
+        return true;
+    }
+    rejectPendingDispatchesForNode(nodeId, errorMessage) {
+        for (const [runId, pending] of this.pendingDispatchAcceptances.entries()) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            pending.reject(new Error(errorMessage));
+            this.pendingDispatchAcceptances.delete(runId);
+        }
+    }
+    getDispatchMode(sessionKey) {
+        const row = this.db.prepare('SELECT acp_session_id as acpSessionId FROM sessions WHERE session_key = ?').get(sessionKey);
+        return row?.acpSessionId?.trim() ? 'resume' : 'cold_start';
+    }
+    hasOpenRun(sessionKey) {
+        const row = this.db.prepare('SELECT 1 as present FROM runs WHERE session_key = ? AND ended_at IS NULL LIMIT 1').get(sessionKey);
+        return Boolean(row);
+    }
+    getCurrentOpenRunId(sessionKey) {
+        const row = this.db.prepare(`SELECT run_id as runId
+         FROM runs
+        WHERE session_key = ?
+          AND ended_at IS NULL
+        ORDER BY started_at ASC, rowid ASC
+        LIMIT 1`).get(sessionKey);
+        return row?.runId ?? null;
+    }
+    waitForDispatchAcceptance(runId, nodeId, workspaceSessionId, sessionKey) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingDispatchAcceptances.delete(runId);
+                reject(new Error('Node did not acknowledge workspace dispatch in time'));
+            }, this.nodeDispatchAckTimeoutMs);
+            this.pendingDispatchAcceptances.set(runId, {
+                nodeId,
+                workspaceSessionId,
+                sessionKey,
+                timer,
+                resolve,
+                reject,
+            });
+        });
+    }
+    clearPendingDispatchAcceptance(runId) {
+        const pending = this.pendingDispatchAcceptances.get(runId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingDispatchAcceptances.delete(runId);
+    }
+    finishDispatchFailure(params) {
+        if (this.isRunEnded(params.runId))
+            return;
+        finishRun(this.db, { runId: params.runId, error: params.error });
+        this.restoreStatusAfterDispatchFailure(params.workspaceSessionId, params.sessionKey, params.previousStatus);
+    }
+    isRunEnded(runId) {
+        const row = this.db.prepare('SELECT ended_at as endedAt FROM runs WHERE run_id = ?').get(runId);
+        return row?.endedAt != null;
+    }
+    restoreStatusAfterDispatchFailure(workspaceSessionId, sessionKey, previousStatus) {
+        const hasRemainingOpenRun = this.hasOpenRun(sessionKey);
+        const hasPendingApproval = this.hasOpenPendingApproval(sessionKey);
+        const status = hasRemainingOpenRun
+            ? hasPendingApproval
+                ? 'awaiting_approval'
+                : previousStatus === 'idle' || previousStatus === 'failed'
+                    ? 'active'
+                    : previousStatus
+            : 'failed';
+        this.workspaceSessionService.updateSessionStatus(workspaceSessionId, status, { touchLastActive: true });
+    }
+    getStatusAfterDispatchStart(sessionKey, queued) {
+        if (this.hasOpenPendingApproval(sessionKey))
+            return 'awaiting_approval';
+        return queued ? 'queued' : 'active';
+    }
+    hasOpenPendingApproval(sessionKey) {
+        return hasOpenPendingWorkspaceApproval(this.db, sessionKey);
+    }
+}
+export function hasOpenPendingWorkspaceApproval(db, sessionKey) {
+    const row = db.prepare(`SELECT 1 as present
+       FROM runs r
+      WHERE r.session_key = ?
+        AND r.ended_at IS NULL
+        AND EXISTS (
+          SELECT 1
+            FROM events approval
+           WHERE approval.run_id = r.run_id
+             AND approval.method = 'node/event'
+             AND json_valid(approval.payload_json)
+             AND json_extract(approval.payload_json, '$.type') = 'approval.request'
+             AND NOT EXISTS (
+               SELECT 1
+                 FROM events response
+                WHERE response.run_id = approval.run_id
+                  AND response.seq > approval.seq
+                  AND json_valid(response.payload_json)
+                  AND (
+                    (
+                      response.method = 'approval/response'
+                      AND json_extract(response.payload_json, '$.type') = 'approval.response'
+                      AND json_extract(response.payload_json, '$.requestId') = json_extract(approval.payload_json, '$.requestId')
+                    )
+                    OR (
+                      response.method = 'node/event'
+                      AND json_extract(response.payload_json, '$.type') IN (${WORKSPACE_APPROVAL_PROGRESS_TYPES_SQL})
+                    )
+                  )
+             )
+        )
+        LIMIT 1`).get(sessionKey);
+    return Boolean(row);
+}
+export function listWorkspaceSessionEvents(db, sessionKey) {
+    const runs = db.prepare(`SELECT run_id as runId,
+            prompt_text as promptText,
+            started_at as startedAt,
+            ended_at as endedAt,
+            stop_reason as stopReason,
+            error
+       FROM runs
+      WHERE session_key = ?
+      ORDER BY started_at ASC, run_id ASC`).all(sessionKey);
+    const entries = [];
+    for (const run of runs) {
+        entries.push({
+            runId: run.runId,
+            seq: 0,
+            createdAt: run.startedAt,
+            event: {
+                type: 'turn.begin',
+                turnId: run.runId,
+                startedAt: run.startedAt,
+                promptText: run.promptText,
+            },
+        });
+        const rows = db.prepare(`SELECT seq,
+              payload_json as payloadJson,
+              created_at as createdAt
+         FROM events
+        WHERE run_id = ?
+          AND method IN ('node/event', 'approval/response')
+        ORDER BY seq ASC`).all(run.runId);
+        let maxSeq = 0;
+        for (const row of rows) {
+            maxSeq = Math.max(maxSeq, row.seq);
+            const event = parseServerEvent(row.payloadJson);
+            if (!event)
+                continue;
+            entries.push({
+                runId: run.runId,
+                seq: row.seq,
+                createdAt: row.createdAt,
+                event,
+            });
+        }
+        if (run.endedAt != null) {
+            entries.push({
+                runId: run.runId,
+                seq: maxSeq + 1,
+                createdAt: run.endedAt,
+                event: {
+                    type: 'turn.end',
+                    turnId: run.runId,
+                    endedAt: run.endedAt,
+                    ...(run.stopReason ? { stopReason: run.stopReason } : {}),
+                    ...(run.error ? { error: run.error } : {}),
+                },
+            });
+        }
+    }
+    return entries.sort((left, right) => left.createdAt - right.createdAt || left.seq - right.seq);
+}
+function normalizePromptText(value) {
+    if (typeof value !== 'string') {
+        throw new WorkspaceSessionServiceError(400, 'Prompt text is required.');
+    }
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new WorkspaceSessionServiceError(400, 'Prompt text is required.');
+    return trimmed;
+}
+function normalizePromptRuntimeOverrides(value) {
+    if (!value)
+        return undefined;
+    const codexMode = value.codexMode === 'default' || value.codexMode === 'plan'
+        ? value.codexMode
+        : null;
+    return codexMode ? { codexMode } : undefined;
+}
+function normalizeRequiredString(value, message) {
+    if (typeof value !== 'string')
+        throw new WorkspaceSessionServiceError(400, message);
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new WorkspaceSessionServiceError(400, message);
+    return trimmed;
+}
+function normalizeOptionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeApprovalDecision(value) {
+    if (value === 'allow' || value === 'deny')
+        return value;
+    throw new WorkspaceSessionServiceError(400, 'Approval decision must be allow or deny.');
+}
+function buildWorkspaceSessionSystemPrompt(agent, workspacePath) {
+    return [
+        `You are "${agent.name}", an AI agent in Bigbang Workspace.`,
+        '',
+        'You are running inside the Workspace surface, not a Chat conversation.',
+        'Use normal assistant output for user-visible replies in this Workspace surface. Do not use Bigbang chat command surfaces here.',
+        `Your current workspace root is: ${workspacePath}`,
+        'Use regular filesystem and terminal tools for work in this root. Maintain MEMORY.md and notes/*.md when durable knowledge should persist.',
+        agent.systemPrompt?.trim() ? `\nInitial role:\n${agent.systemPrompt.trim()}` : '',
+        agent.description?.trim() ? `\nAgent description:\n${agent.description.trim()}` : '',
+    ].filter(Boolean).join('\n');
+}
+function buildWorkspaceSessionContextText(workspaceSessionId, workspacePath) {
+    return [
+        '[Workspace session]',
+        `workspace_session_id: ${workspaceSessionId}`,
+        `workspace_root: ${workspacePath}`,
+        'surface: Workspace',
+    ].join('\n');
+}
+function updateSessionCwd(db, sessionKey, cwd) {
+    db.prepare('UPDATE sessions SET cwd = ?, updated_at = ? WHERE session_key = ?').run(cwd, Date.now(), sessionKey);
+}
+function findPendingApprovalRunId(db, sessionKey, requestId) {
+    const row = db.prepare(`SELECT r.run_id as runId
+       FROM runs r
+      WHERE r.session_key = ?
+        AND r.ended_at IS NULL
+        AND EXISTS (
+          SELECT 1
+            FROM events approval
+           WHERE approval.run_id = r.run_id
+             AND approval.method = 'node/event'
+             AND json_valid(approval.payload_json)
+             AND json_extract(approval.payload_json, '$.type') = 'approval.request'
+             AND json_extract(approval.payload_json, '$.requestId') = ?
+             AND NOT EXISTS (
+               SELECT 1
+                 FROM events later
+                WHERE later.run_id = approval.run_id
+                  AND later.seq > approval.seq
+                  AND json_valid(later.payload_json)
+                  AND (
+                    (
+                      later.method = 'approval/response'
+                      AND json_extract(later.payload_json, '$.type') = 'approval.response'
+                      AND json_extract(later.payload_json, '$.requestId') = ?
+                    )
+                    OR (
+                      later.method = '${WORKSPACE_APPROVAL_RESPONSE_SENT_METHOD}'
+                      AND json_extract(later.payload_json, '$.type') = 'approval.response'
+                      AND json_extract(later.payload_json, '$.requestId') = ?
+                    )
+                    OR (
+                      later.method = 'node/event'
+                      AND json_extract(later.payload_json, '$.type') IN (${WORKSPACE_APPROVAL_PROGRESS_TYPES_SQL})
+                    )
+                  )
+             )
+        )
+      ORDER BY r.started_at DESC
+      LIMIT 1`).get(sessionKey, requestId, requestId, requestId);
+    return row?.runId ?? null;
+}
+export function isWorkspaceApprovalProgressEvent(event) {
+    return event.type === 'content.delta'
+        || event.type === 'thinking.delta'
+        || event.type === 'tool.call'
+        || event.type === 'tool.result'
+        || event.type === 'plan.update'
+        || event.type === 'plan.phase'
+        || event.type === 'task.update'
+        || event.type === 'runtime.compact';
+}
+export function promoteWorkspaceSentApprovalResponses(db, runId) {
+    const rows = db.prepare(`SELECT sent.payload_json as payloadJson
+       FROM events sent
+       JOIN events approval
+         ON approval.run_id = sent.run_id
+        AND approval.method = 'node/event'
+        AND json_valid(approval.payload_json)
+        AND json_extract(approval.payload_json, '$.type') = 'approval.request'
+        AND json_extract(approval.payload_json, '$.requestId') = json_extract(sent.payload_json, '$.requestId')
+        AND sent.seq > approval.seq
+      WHERE sent.run_id = ?
+        AND sent.method = '${WORKSPACE_APPROVAL_RESPONSE_SENT_METHOD}'
+        AND json_valid(sent.payload_json)
+        AND json_extract(sent.payload_json, '$.type') = 'approval.response'
+        AND NOT EXISTS (
+          SELECT 1
+            FROM events response
+           WHERE response.run_id = sent.run_id
+             AND response.seq > approval.seq
+             AND response.method = 'approval/response'
+             AND json_valid(response.payload_json)
+             AND json_extract(response.payload_json, '$.type') = 'approval.response'
+             AND json_extract(response.payload_json, '$.requestId') = json_extract(sent.payload_json, '$.requestId')
+        )
+      ORDER BY sent.seq ASC`).all(runId);
+    for (const row of rows) {
+        const seqRow = db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 as nextSeq
+         FROM events
+        WHERE run_id = ?
+          AND seq > 0`).get(runId);
+        db.prepare(`INSERT OR IGNORE INTO events(run_id, seq, method, payload_json, created_at)
+       VALUES(?, ?, 'approval/response', ?, ?)`).run(runId, seqRow?.nextSeq ?? 1, row.payloadJson, Date.now());
+    }
+}
+function persistApprovalResponseSentMarker(db, runId, requestId, decision, selectedActionId, responseText) {
+    const seqRow = db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 as nextSeq
+       FROM events
+      WHERE run_id = ?
+        AND seq > 0`).get(runId);
+    const payload = {
+        type: 'approval.response',
+        requestId,
+        decision,
+        ...(selectedActionId ? { selectedActionId } : {}),
+        ...(responseText ? { responseText } : {}),
+    };
+    db.prepare(`INSERT OR IGNORE INTO events(run_id, seq, method, payload_json, created_at)
+     VALUES(?, ?, '${WORKSPACE_APPROVAL_RESPONSE_SENT_METHOD}', ?, ?)`).run(runId, seqRow?.nextSeq ?? 1, JSON.stringify(payload), Date.now());
+}
+function parseServerEvent(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && typeof parsed.type === 'string' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}