pulseed 0.5.2 → 0.5.4

package/dist/tools/query/runtime-session-tools.js

@@ -0,0 +1,1015 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { ChatHistory, ChatSessionSchema } from "../../interface/chat/chat-history.js";
+import { ChatSessionCatalog } from "../../interface/chat/chat-session-store.js";
+import { createRuntimeSessionRegistry } from "../../runtime/session-registry/index.js";
+import { OutboxStore } from "../../runtime/store/outbox-store.js";
+const READ_ONLY = true;
+const READ_PERMISSION = "read_only";
+const WRITE_PERMISSION = "write_local";
+const TAGS = ["session", "self-grounding"];
+function normalizeConversationSelector(selector) {
+    return selector.startsWith("session:conversation:")
+        ? selector.slice("session:conversation:".length)
+        : selector;
+}
+function toConversationRuntimeId(sessionId) {
+    return `session:conversation:${sessionId}`;
+}
+function buildCompletionMessage(session, status, summary) {
+    const title = session.title ? ` "${session.title}"` : "";
+    return `Session ${session.id}${title} ${status}: ${summary}`;
+}
+function summarizeMessages(messages, limit) {
+    return messages.slice(-limit).map((message) => ({
+        role: message.role,
+        content: message.content,
+        timestamp: message.timestamp,
+        turnIndex: message.turnIndex,
+    }));
+}
+function reindexMessages(messages) {
+    return messages.map((message, index) => ({
+        role: message.role,
+        content: message.content,
+        timestamp: message.timestamp,
+        turnIndex: index,
+    }));
+}
+function toChatSessionRecord(session) {
+    return {
+        id: session.id,
+        cwd: session.cwd,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        messages: [...session.messages],
+        ...(session.parentSessionId ? { parentSessionId: session.parentSessionId } : {}),
+        ...(session.spawnedBySessionId ? { spawnedBySessionId: session.spawnedBySessionId } : {}),
+        ...(session.spawnedByRuntimeSessionId ? { spawnedByRuntimeSessionId: session.spawnedByRuntimeSessionId } : {}),
+        ...(session.spawnedAt ? { spawnedAt: session.spawnedAt } : {}),
+        ...(session.sessionStatus ? { sessionStatus: session.sessionStatus } : {}),
+        ...(session.sessionSummary ? { sessionSummary: session.sessionSummary } : {}),
+        ...(session.completedAt ? { completedAt: session.completedAt } : {}),
+        ...(session.goalId ? { goalId: session.goalId } : {}),
+        ...(session.strategyId ? { strategyId: session.strategyId } : {}),
+        ...(session.notificationPolicy ? { notificationPolicy: session.notificationPolicy } : {}),
+        ...(session.ownerId ? { ownerId: session.ownerId } : {}),
+        ...(session.ownerClaimedAt ? { ownerClaimedAt: session.ownerClaimedAt } : {}),
+        ...(session.waitingUntil ? { waitingUntil: session.waitingUntil } : {}),
+        ...(session.waitingCondition ? { waitingCondition: session.waitingCondition } : {}),
+        ...(session.retryCount !== null && session.retryCount !== undefined ? { retryCount: session.retryCount } : {}),
+        ...(session.lastRetryAt ? { lastRetryAt: session.lastRetryAt } : {}),
+        ...(session.lastResumedAt ? { lastResumedAt: session.lastResumedAt } : {}),
+        ...(session.notificationReplyTarget ? { notificationReplyTarget: session.notificationReplyTarget } : {}),
+        ...(session.parentNotificationStatus ? { parentNotificationStatus: session.parentNotificationStatus } : {}),
+        ...(session.parentNotificationSummary ? { parentNotificationSummary: session.parentNotificationSummary } : {}),
+        ...(session.parentNotifiedAt ? { parentNotifiedAt: session.parentNotifiedAt } : {}),
+        ...(session.compactionSummary ? { compactionSummary: session.compactionSummary } : {}),
+        ...(session.title ? { title: session.title } : {}),
+        ...(session.agentLoopStatePath ? { agentLoopStatePath: session.agentLoopStatePath } : {}),
+        ...(session.agentLoopStatus === "running" || session.agentLoopStatus === "completed" || session.agentLoopStatus === "failed"
+            ? { agentLoopStatus: session.agentLoopStatus }
+            : {}),
+        ...(session.agentLoopResumable ? { agentLoopResumable: true } : {}),
+        ...(session.agentLoopUpdatedAt ? { agentLoopUpdatedAt: session.agentLoopUpdatedAt } : {}),
+        ...(session.agentLoop ? { agentLoop: session.agentLoop } : {}),
+        ...(session.usage ? { usage: session.usage } : {}),
+    };
+}
+class RuntimeSessionToolService {
+    stateManager;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    catalog() {
+        return new ChatSessionCatalog(this.stateManager);
+    }
+    registry() {
+        return createRuntimeSessionRegistry({ stateManager: this.stateManager });
+    }
+    outbox() {
+        return new OutboxStore(this.stateManager.getBaseDir());
+    }
+    async listSessions(input, context) {
+        const snapshot = await this.registry().snapshot();
+        const allowedConversationIds = await this.allowedConversationIds(input.scope, context);
+        const runtimeAllowedIds = allowedConversationIds
+            ? new Set(Array.from(allowedConversationIds, (id) => toConversationRuntimeId(id)))
+            : null;
+        const kindFilter = input.kinds?.length ? new Set(input.kinds) : null;
+        const sessions = snapshot.sessions.filter((session) => {
+            if (kindFilter && !kindFilter.has(session.kind))
+                return false;
+            if (input.activeOnly && session.status !== "active")
+                return false;
+            if (!runtimeAllowedIds)
+                return true;
+            if (session.kind === "conversation")
+                return runtimeAllowedIds.has(session.id);
+            return session.parent_session_id ? runtimeAllowedIds.has(session.parent_session_id) : false;
+        });
+        if (!input.includeRuns) {
+            return { sessions };
+        }
+        const runs = snapshot.background_runs.filter((run) => {
+            if (!runtimeAllowedIds)
+                return true;
+            if (run.parent_session_id && runtimeAllowedIds.has(run.parent_session_id))
+                return true;
+            return run.child_session_id ? sessions.some((session) => session.id === run.child_session_id) : false;
+        });
+        return { sessions, runs };
+    }
+    async loadHistory(selector, limit) {
+        const session = await this.resolveConversationSession(selector);
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            title: session.title,
+            parentSessionId: session.parentSessionId ?? null,
+            cwd: session.cwd,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            ...(session.compactionSummary ? { compactionSummary: session.compactionSummary } : {}),
+            messages: summarizeMessages(session.messages, limit),
+        };
+    }
+    async readSession(selector) {
+        const session = await this.resolveConversationSession(selector);
+        const entries = await this.catalog().listSessions();
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            title: session.title,
+            parentSessionId: session.parentSessionId ?? null,
+            childSessionIds: entries.filter((entry) => entry.parentSessionId === session.id).map((entry) => entry.id),
+            cwd: session.cwd,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            sessionStatus: session.sessionStatus ?? null,
+            sessionSummary: session.sessionSummary ?? null,
+            completedAt: session.completedAt ?? null,
+            goalId: session.goalId ?? null,
+            strategyId: session.strategyId ?? null,
+            notificationPolicy: session.notificationPolicy ?? null,
+            ownerId: session.ownerId ?? null,
+            ownerClaimedAt: session.ownerClaimedAt ?? null,
+            waitingUntil: session.waitingUntil ?? null,
+            waitingCondition: session.waitingCondition ?? null,
+            retryCount: session.retryCount ?? null,
+            lastRetryAt: session.lastRetryAt ?? null,
+            lastResumedAt: session.lastResumedAt ?? null,
+            parentNotificationStatus: session.parentNotificationStatus ?? null,
+            parentNotifiedAt: session.parentNotifiedAt ?? null,
+            notificationReplyTarget: session.notificationReplyTarget ?? null,
+        };
+    }
+    async listChildren(selector) {
+        const session = await this.resolveConversationSession(selector);
+        const entries = await this.catalog().listSessions();
+        const loadedChildren = await Promise.all(entries
+            .filter((entry) => entry.parentSessionId === session.id)
+            .map((entry) => this.catalog().loadSession(entry.id)));
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            children: loadedChildren
+                .filter((child) => child !== null)
+                .map((child) => ({
+                sessionId: child.id,
+                runtimeSessionId: toConversationRuntimeId(child.id),
+                title: child.title,
+                sessionStatus: child.sessionStatus ?? null,
+                goalId: child.goalId ?? null,
+                strategyId: child.strategyId ?? null,
+                waitingUntil: child.waitingUntil ?? null,
+                ownerId: child.ownerId ?? null,
+            })),
+        };
+    }
+    async spawnSession(input, context) {
+        const now = new Date().toISOString();
+        const sessionId = randomUUID();
+        const parentSessionId = context.conversationSessionId ?? null;
+        const baseSession = input.copy_recent_messages && parentSessionId
+            ? await this.catalog().loadSession(parentSessionId)
+            : null;
+        const seededMessages = input.copy_recent_messages && baseSession
+            ? reindexMessages(baseSession.messages.slice(-input.recent_message_limit))
+            : [];
+        const persisted = ChatSessionSchema.parse({
+            id: sessionId,
+            cwd: input.cwd?.trim() || context.cwd,
+            createdAt: now,
+            updatedAt: now,
+            messages: seededMessages,
+            ...(input.title?.trim() ? { title: input.title.trim() } : {}),
+            ...(parentSessionId ? { parentSessionId } : {}),
+            ...(parentSessionId ? { spawnedBySessionId: parentSessionId } : {}),
+            ...(context.sessionId ? { spawnedByRuntimeSessionId: context.sessionId } : {}),
+            spawnedAt: now,
+            ...(input.goal_id?.trim() ? { goalId: input.goal_id.trim() } : {}),
+            ...(input.strategy_id?.trim() ? { strategyId: input.strategy_id.trim() } : {}),
+            notificationPolicy: input.notification_policy ?? (parentSessionId ? "all_terminal" : "important_only"),
+            ...(input.owner_id?.trim() ? { ownerId: input.owner_id.trim() } : {}),
+            ...(input.owner_id?.trim() ? { ownerClaimedAt: now } : {}),
+            sessionStatus: input.message?.trim() ? "queued" : "idle",
+            parentNotificationStatus: parentSessionId ? "pending" : "none",
+            ...(baseSession?.notificationReplyTarget ? { notificationReplyTarget: baseSession.notificationReplyTarget } : {}),
+            agentLoopStatePath: `chat/agentloop/${sessionId}.state.json`,
+        });
+        const history = ChatHistory.fromSession(this.stateManager, persisted);
+        if (input.message?.trim()) {
+            await history.appendUserMessage(input.message.trim());
+        }
+        else {
+            await history.persist();
+        }
+        return {
+            sessionId,
+            runtimeSessionId: toConversationRuntimeId(sessionId),
+            parentSessionId,
+            resumeCommand: `/resume session:conversation:${sessionId}`,
+            messageQueued: Boolean(input.message?.trim()),
+        };
+    }
+    async sendToSession(selector, message) {
+        const session = await this.resolveConversationSession(selector);
+        const history = ChatHistory.fromSession(this.stateManager, toChatSessionRecord(session));
+        history.setSessionLifecycle({ status: "queued" });
+        await history.appendUserMessage(message.trim());
+        const updated = history.getSessionData();
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            messageCount: updated.messages.length,
+            updatedAt: updated.updatedAt ?? updated.createdAt,
+        };
+    }
+    async updateSession(selector, input) {
+        const session = await this.resolveConversationSession(selector);
+        const history = ChatHistory.fromSession(this.stateManager, toChatSessionRecord(session));
+        const completedAt = input.status === "completed" || input.status === "failed"
+            ? (input.completed_at ?? new Date().toISOString())
+            : null;
+        history.setSessionLifecycle({
+            status: input.status,
+            summary: input.summary ?? undefined,
+            completedAt,
+            goalId: input.goal_id ?? undefined,
+            strategyId: input.strategy_id ?? undefined,
+            notificationPolicy: input.notification_policy ?? undefined,
+            waitingUntil: input.waiting_until ?? (input.status === "waiting" ? null : undefined),
+            waitingCondition: input.waiting_condition ?? (input.status === "waiting" ? null : undefined),
+            lastResumedAt: input.status === "running" ? new Date().toISOString() : undefined,
+            parentNotificationStatus: session.parentSessionId && input.notify_parent ? "pending" : undefined,
+        });
+        if (input.append_assistant_message && input.summary?.trim()) {
+            await history.appendAssistantMessage(input.summary.trim());
+        }
+        else {
+            await history.persist();
+        }
+        let notified = false;
+        let parentNotificationStatus = session.parentNotificationStatus ?? null;
+        if (session.parentSessionId
+            && input.notify_parent
+            && input.summary?.trim()
+            && (input.status === "completed" || input.status === "failed")) {
+            try {
+                await this.notifyParentSession(session, input.status, input.summary.trim(), completedAt ?? new Date().toISOString());
+                parentNotificationStatus = "sent";
+                notified = true;
+            }
+            catch {
+                parentNotificationStatus = "failed";
+            }
+            const refreshed = ChatHistory.fromSession(this.stateManager, {
+                ...history.getSessionData(),
+            });
+            refreshed.setSessionLifecycle({
+                parentNotificationStatus,
+                parentNotificationSummary: input.summary.trim(),
+                parentNotifiedAt: notified ? new Date().toISOString() : null,
+            });
+            await refreshed.persist();
+        }
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            status: input.status,
+            parentSessionId: session.parentSessionId ?? null,
+            parentNotificationStatus,
+            notified,
+        };
+    }
+    async claimSession(selector, ownerId) {
+        const session = await this.resolveConversationSession(selector);
+        const history = ChatHistory.fromSession(this.stateManager, toChatSessionRecord(session));
+        const ownerClaimedAt = new Date().toISOString();
+        history.setSessionLifecycle({ ownerId, ownerClaimedAt });
+        await history.persist();
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            ownerId,
+            ownerClaimedAt,
+        };
+    }
+    async cancelSession(selector, reason) {
+        await this.updateSession(selector, {
+            session_id: selector,
+            status: "failed",
+            summary: reason,
+            append_assistant_message: false,
+            notify_parent: true,
+        });
+        const session = await this.resolveConversationSession(selector);
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            status: "failed",
+        };
+    }
+    async retrySession(selector, message) {
+        const session = await this.resolveConversationSession(selector);
+        const history = ChatHistory.fromSession(this.stateManager, toChatSessionRecord(session));
+        const retryCount = (session.retryCount ?? 0) + 1;
+        const now = new Date().toISOString();
+        history.setSessionLifecycle({
+            status: "queued",
+            completedAt: null,
+            summary: null,
+            retryCount,
+            lastRetryAt: now,
+            waitingUntil: null,
+            waitingCondition: null,
+            parentNotificationStatus: session.parentSessionId ? "pending" : session.parentNotificationStatus ?? null,
+        });
+        if (message?.trim()) {
+            await history.appendUserMessage(message.trim());
+        }
+        else {
+            await history.persist();
+        }
+        return {
+            sessionId: session.id,
+            runtimeSessionId: toConversationRuntimeId(session.id),
+            retryCount,
+            status: "queued",
+        };
+    }
+    async notifyParentSession(childSession, status, summary, completedAt) {
+        const parentSession = await this.resolveConversationSession(childSession.parentSessionId);
+        const parentHistory = ChatHistory.fromSession(this.stateManager, toChatSessionRecord(parentSession));
+        const message = buildCompletionMessage(childSession, status, summary);
+        await parentHistory.appendAssistantMessage(message);
+        const replyTarget = parentSession.notificationReplyTarget ?? childSession.notificationReplyTarget ?? null;
+        if (!replyTarget)
+            return;
+        const outbox = this.outbox();
+        const createdAt = Date.now();
+        await outbox.append({
+            event_type: "session_completion",
+            correlation_id: childSession.id,
+            created_at: createdAt,
+            payload: {
+                session_id: childSession.id,
+                runtime_session_id: toConversationRuntimeId(childSession.id),
+                parent_session_id: childSession.parentSessionId,
+                status,
+                summary,
+                completed_at: completedAt,
+                reply_target: replyTarget,
+            },
+        });
+        await outbox.append({
+            event_type: "chat_response",
+            correlation_id: childSession.id,
+            created_at: Date.now(),
+            payload: {
+                goalId: `session:${childSession.id}`,
+                goal_id: `session:${childSession.id}`,
+                message,
+                status,
+                reply_target: replyTarget,
+                session_completion: {
+                    session_id: childSession.id,
+                    runtime_session_id: toConversationRuntimeId(childSession.id),
+                    parent_session_id: childSession.parentSessionId,
+                    status,
+                    summary,
+                    completed_at: completedAt,
+                },
+            },
+        });
+    }
+    async resolveConversationSession(selector) {
+        const session = await this.catalog().loadSessionBySelector(normalizeConversationSelector(selector));
+        if (!session) {
+            throw new Error(`No chat session matched selector "${selector}".`);
+        }
+        return session;
+    }
+    async allowedConversationIds(scope, context) {
+        const currentConversationId = context.conversationSessionId ?? null;
+        if (scope === "all" || !currentConversationId)
+            return null;
+        if (scope === "self")
+            return new Set([currentConversationId]);
+        const entries = await this.catalog().listSessions();
+        const descendants = new Set([currentConversationId]);
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const entry of entries) {
+                if (!entry.parentSessionId)
+                    continue;
+                if (descendants.has(entry.parentSessionId) && !descendants.has(entry.id)) {
+                    descendants.add(entry.id);
+                    changed = true;
+                }
+            }
+        }
+        return descendants;
+    }
+}
+export const RuntimeSessionsListInputSchema = z.object({
+    scope: z.enum(["self", "tree", "all"]).default("tree"),
+    kinds: z.array(z.enum(["conversation", "agent", "coreloop"])).optional(),
+    activeOnly: z.boolean().default(false),
+    includeRuns: z.boolean().default(false),
+});
+export class RuntimeSessionsListTool {
+    service;
+    metadata = {
+        name: "sessions_list",
+        aliases: ["list_sessions", "runtime_sessions_list"],
+        permissionLevel: READ_PERMISSION,
+        isReadOnly: READ_ONLY,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 0,
+        maxOutputChars: 12000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsListInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description(_context) {
+        return "List PulSeed runtime sessions. Supports current-session scope, spawned-session tree scope, or all sessions.";
+    }
+    async call(input, context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.listSessions(input, context);
+            return {
+                success: true,
+                data,
+                summary: `Found ${data.sessions.length} session(s)`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_list failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return true;
+    }
+}
+export const RuntimeSessionsHistoryInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    limit: z.number().int().positive().max(100).default(20),
+});
+export class RuntimeSessionsHistoryTool {
+    service;
+    metadata = {
+        name: "sessions_history",
+        aliases: ["read_session_history", "runtime_session_history"],
+        permissionLevel: READ_PERMISSION,
+        isReadOnly: READ_ONLY,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 0,
+        maxOutputChars: 12000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsHistoryInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description(_context) {
+        return "Read recent message history from a PulSeed chat conversation session by chat id or runtime session id.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.loadHistory(input.session_id, input.limit);
+            return {
+                success: true,
+                data,
+                summary: `Loaded ${data.messages.length} message(s) from session ${data.sessionId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_history failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return true;
+    }
+}
+export const RuntimeSessionsReadInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+});
+export class RuntimeSessionsReadTool {
+    service;
+    metadata = {
+        name: "sessions_read",
+        aliases: ["read_session", "runtime_session_read"],
+        permissionLevel: READ_PERMISSION,
+        isReadOnly: READ_ONLY,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 0,
+        maxOutputChars: 12000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsReadInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "Read one PulSeed conversation session with parent/child relationships, lifecycle state, and notification metadata.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.readSession(input.session_id);
+            return {
+                success: true,
+                data,
+                summary: `Loaded session ${data.sessionId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_read failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return true;
+    }
+}
+export const RuntimeSessionsChildrenInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+});
+export class RuntimeSessionsChildrenTool {
+    service;
+    metadata = {
+        name: "sessions_children",
+        aliases: ["list_session_children", "runtime_session_children"],
+        permissionLevel: READ_PERMISSION,
+        isReadOnly: READ_ONLY,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 0,
+        maxOutputChars: 12000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsChildrenInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "List child conversation sessions spawned from a PulSeed conversation session.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.listChildren(input.session_id);
+            return {
+                success: true,
+                data,
+                summary: `Loaded ${data.children.length} child session(s) for ${data.sessionId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_children failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return true;
+    }
+}
+export const RuntimeSessionsSpawnInputSchema = z.object({
+    title: z.string().trim().min(1).max(200).optional(),
+    message: z.string().trim().min(1).optional(),
+    cwd: z.string().trim().min(1).optional(),
+    goal_id: z.string().trim().min(1).optional(),
+    strategy_id: z.string().trim().min(1).optional(),
+    notification_policy: z.enum(["silent", "important_only", "periodic", "all_terminal"]).optional(),
+    owner_id: z.string().trim().min(1).optional(),
+    copy_recent_messages: z.boolean().default(false),
+    recent_message_limit: z.number().int().positive().max(20).default(6),
+});
+export class RuntimeSessionsSpawnTool {
+    service;
+    metadata = {
+        name: "sessions_spawn",
+        aliases: ["spawn_session_runtime", "delegate_session"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsSpawnInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description(_context) {
+        return "Create a new PulSeed chat conversation session, optionally seeded with a task message, so work can be moved into a separate session.";
+    }
+    async call(input, context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.spawnSession(input, context);
+            return {
+                success: true,
+                data,
+                summary: `Spawned session ${data.sessionId}`,
+                contextModifier: `Use ${data.resumeCommand} to continue the delegated work in that separate session.`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_spawn failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export const RuntimeSessionsSendInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    message: z.string().trim().min(1, "message is required"),
+});
+export class RuntimeSessionsSendTool {
+    service;
+    metadata = {
+        name: "sessions_send",
+        aliases: ["send_session_message", "enqueue_session_message"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsSendInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description(_context) {
+        return "Append a user message to another PulSeed chat conversation session by chat id or runtime session id.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.sendToSession(input.session_id, input.message);
+            return {
+                success: true,
+                data,
+                summary: `Queued a message for session ${data.sessionId}`,
+                contextModifier: `Resume ${data.runtimeSessionId} later to act on the queued message in that separate session.`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_send failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export const RuntimeSessionsUpdateInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    status: z.enum(["queued", "running", "waiting", "completed", "failed"]),
+    summary: z.string().trim().min(1).optional(),
+    goal_id: z.string().trim().min(1).optional(),
+    strategy_id: z.string().trim().min(1).optional(),
+    notification_policy: z.enum(["silent", "important_only", "periodic", "all_terminal"]).optional(),
+    waiting_until: z.string().trim().min(1).nullable().optional(),
+    waiting_condition: z.string().trim().min(1).nullable().optional(),
+    append_assistant_message: z.boolean().default(false),
+    notify_parent: z.boolean().default(false),
+    completed_at: z.string().optional(),
+}).superRefine((value, ctx) => {
+    if ((value.status === "completed" || value.status === "failed") && !value.summary) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["summary"],
+            message: "summary is required when marking a session completed or failed",
+        });
+    }
+    if (value.status === "waiting" && !value.waiting_until && !value.waiting_condition) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["waiting_until"],
+            message: "waiting_until or waiting_condition is required when marking a session waiting",
+        });
+    }
+});
+export class RuntimeSessionsUpdateTool {
+    service;
+    metadata = {
+        name: "sessions_update",
+        aliases: ["update_session_status", "complete_session", "fail_session"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsUpdateInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "Update a PulSeed conversation session lifecycle state. Can mark child sessions completed or failed and notify the parent session durably.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.updateSession(input.session_id, input);
+            return {
+                success: true,
+                data,
+                summary: `Updated session ${data.sessionId} to ${data.status}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_update failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export const RuntimeSessionsClaimInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    owner_id: z.string().trim().min(1, "owner_id is required"),
+});
+export class RuntimeSessionsClaimTool {
+    service;
+    metadata = {
+        name: "sessions_claim",
+        aliases: ["claim_session", "runtime_session_claim"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsClaimInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "Claim ownership of a PulSeed conversation session so delegated work has an explicit owner.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.claimSession(input.session_id, input.owner_id);
+            return {
+                success: true,
+                data,
+                summary: `Claimed session ${data.sessionId} for ${data.ownerId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_claim failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export const RuntimeSessionsCancelInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    reason: z.string().trim().min(1, "reason is required"),
+});
+export class RuntimeSessionsCancelTool {
+    service;
+    metadata = {
+        name: "sessions_cancel",
+        aliases: ["cancel_session", "runtime_session_cancel"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsCancelInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "Cancel a PulSeed conversation session by marking it failed and notifying its parent if configured.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.cancelSession(input.session_id, input.reason);
+            return {
+                success: true,
+                data,
+                summary: `Canceled session ${data.sessionId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_cancel failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export const RuntimeSessionsRetryInputSchema = z.object({
+    session_id: z.string().min(1, "session_id is required"),
+    message: z.string().trim().min(1).optional(),
+});
+export class RuntimeSessionsRetryTool {
+    service;
+    metadata = {
+        name: "sessions_retry",
+        aliases: ["retry_session", "runtime_session_retry"],
+        permissionLevel: WRITE_PERMISSION,
+        isReadOnly: false,
+        isDestructive: false,
+        shouldDefer: false,
+        alwaysLoad: false,
+        maxConcurrency: 1,
+        maxOutputChars: 8000,
+        tags: [...TAGS],
+    };
+    inputSchema = RuntimeSessionsRetryInputSchema;
+    constructor(service) {
+        this.service = service;
+    }
+    description() {
+        return "Re-queue a PulSeed conversation session for another attempt, preserving retry metadata.";
+    }
+    async call(input, _context) {
+        const started = Date.now();
+        try {
+            const data = await this.service.retrySession(input.session_id, input.message);
+            return {
+                success: true,
+                data,
+                summary: `Retried session ${data.sessionId}`,
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                summary: `sessions_retry failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    async checkPermissions() {
+        return { status: "allowed" };
+    }
+    isConcurrencySafe() {
+        return false;
+    }
+}
+export function createRuntimeSessionTools(stateManager) {
+    const service = new RuntimeSessionToolService(stateManager);
+    return [
+        new RuntimeSessionsListTool(service),
+        new RuntimeSessionsHistoryTool(service),
+        new RuntimeSessionsReadTool(service),
+        new RuntimeSessionsChildrenTool(service),
+        new RuntimeSessionsSpawnTool(service),
+        new RuntimeSessionsSendTool(service),
+        new RuntimeSessionsUpdateTool(service),
+        new RuntimeSessionsClaimTool(service),
+        new RuntimeSessionsCancelTool(service),
+        new RuntimeSessionsRetryTool(service),
+    ];
+}
+//# sourceMappingURL=runtime-session-tools.js.map