@runtypelabs/sdk 1.7.2 → 1.7.3

package/dist/endpoints.js

@@ -1,2936 +0,0 @@
-"use strict";
-/**
- * API endpoint handlers with automatic camelCase/snake_case transformation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentsEndpoint = exports.ClientTokensEndpoint = exports.EvalEndpoint = exports.ToolsEndpoint = exports.ContextTemplatesEndpoint = exports.FlowStepsEndpoint = exports.AnalyticsEndpoint = exports.UsersEndpoint = exports.ChatEndpoint = exports.DispatchEndpoint = exports.ModelConfigsEndpoint = exports.ApiKeysEndpoint = exports.RecordsEndpoint = exports.PromptsEndpoint = exports.FlowsEndpoint = void 0;
-const generated_tool_gate_1 = require("./generated-tool-gate");
-/**
- * Flows endpoint handlers
- */
-class FlowsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all flows for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/flows', params);
-    }
-    /**
-     * Get a specific flow by ID
-     */
-    async get(id) {
-        const response = await this.client.get(`/flows/${id}`);
-        return response;
-    }
-    /**
-     * Create a new flow
-     */
-    async create(data) {
-        return this.client.post('/flows', data);
-    }
-    /**
-     * Update an existing flow
-     */
-    async update(id, data) {
-        return this.client.put(`/flows/${id}`, data);
-    }
-    /**
-     * Delete a flow
-     */
-    async delete(id) {
-        return this.client.delete(`/flows/${id}`);
-    }
-    /**
-     * Run a flow on all records of a specific type
-     */
-    async runOnRecordType(id, recordType) {
-        return this.client.post(`/flows/${id}/run-on-record-type`, {
-            recordType,
-        });
-    }
-    /**
-     * Publish flow (promote draft to published)
-     */
-    async publish(id) {
-        return this.client.post(`/flows/${id}/publish`);
-    }
-}
-exports.FlowsEndpoint = FlowsEndpoint;
-/**
- * Prompts endpoint handlers
- */
-class PromptsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all prompts for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/prompts', params);
-    }
-    /**
-     * Get a specific prompt by ID
-     */
-    async get(id) {
-        return this.client.get(`/prompts/${id}`);
-    }
-    /**
-     * Create a new prompt
-     */
-    async create(data) {
-        return this.client.post('/prompts', data);
-    }
-    /**
-     * Update an existing prompt
-     */
-    async update(id, data) {
-        return this.client.put(`/prompts/${id}`, data);
-    }
-    /**
-     * Delete a prompt
-     */
-    async delete(id) {
-        return this.client.delete(`/prompts/${id}`);
-    }
-    /**
-     * Run a prompt on a specific record
-     */
-    async runOnRecord(id, recordId) {
-        return this.client.post(`/prompts/${id}/run-on-record`, { recordId });
-    }
-    /**
-     * Get flows using this prompt
-     */
-    async getFlows(id) {
-        return this.client.get(`/prompts/${id}/flows`);
-    }
-    /**
-     * Update flow attachments for a prompt
-     */
-    async updateFlows(id, flowIds) {
-        return this.client.put(`/prompts/${id}/flows`, { flowIds });
-    }
-}
-exports.PromptsEndpoint = PromptsEndpoint;
-/**
- * Records endpoint handlers
- */
-class RecordsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all records for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/records', params);
-    }
-    /**
-     * Get a specific record by ID
-     */
-    async get(id) {
-        return this.client.get(`/records/${id}`);
-    }
-    /**
-     * Create a new record
-     */
-    async create(data) {
-        return this.client.post('/records', data);
-    }
-    /**
-     * Update an existing record
-     */
-    async update(id, data) {
-        return this.client.put(`/records/${id}`, data);
-    }
-    /**
-     * Delete a record
-     */
-    async delete(id) {
-        return this.client.delete(`/records/${id}`);
-    }
-    /**
-     * Bulk delete multiple records
-     */
-    async bulkDelete(ids) {
-        return this.client.post('/records/bulk-delete', { ids });
-    }
-    /**
-     * Bulk edit multiple records
-     */
-    async bulkEdit(data) {
-        return this.client.post('/records/bulk-edit', data);
-    }
-    /**
-     * Get results for a record
-     */
-    async getResults(id, params) {
-        return this.client.get(`/records/${id}/results`, params);
-    }
-    /**
-     * Delete a specific result for a record
-     */
-    async deleteResult(id, resultId) {
-        return this.client.delete(`/records/${id}/results`, { resultId });
-    }
-    /**
-     * Upload CSV file to create multiple records
-     */
-    async uploadCsv(file, params) {
-        const formData = new FormData();
-        formData.append('file', file);
-        if (params?.typeColumn) {
-            formData.append('typeColumn', params.typeColumn);
-        }
-        if (params?.nameColumn) {
-            formData.append('nameColumn', params.nameColumn);
-        }
-        return this.client.postFormData('/records/upload-csv', formData);
-    }
-    /**
-     * Get record types (distinct values)
-     */
-    async getTypes() {
-        return this.client.get('/records?distinct=types');
-    }
-    /**
-     * Get example record by type and/or name
-     */
-    async getExample(params) {
-        return this.client.get('/records', {
-            ...params,
-            includeFields: true,
-            limit: 1,
-        });
-    }
-}
-exports.RecordsEndpoint = RecordsEndpoint;
-/**
- * API Keys endpoint handlers
- */
-class ApiKeysEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all API keys for the authenticated user
-     */
-    async list() {
-        const response = await this.client.get('/api-keys');
-        return response.apiKeys;
-    }
-    /**
-     * Get a specific API key by ID
-     */
-    async get(id) {
-        return this.client.get(`/api-keys/${id}`);
-    }
-    /**
-     * Create a new API key
-     */
-    async create(data) {
-        return this.client.post('/api-keys', data);
-    }
-    /**
-     * Update an existing API key
-     */
-    async update(id, data) {
-        return this.client.put(`/api-keys/${id}`, data);
-    }
-    /**
-     * Delete an API key
-     */
-    async delete(id) {
-        return this.client.delete(`/api-keys/${id}`);
-    }
-    /**
-     * Regenerate an API key
-     */
-    async regenerate(id) {
-        return this.client.post(`/api-keys/${id}/regenerate`);
-    }
-    /**
-     * Get API key analytics
-     */
-    async getAnalytics(id) {
-        return this.client.get(`/api-keys/${id}/analytics`);
-    }
-    /**
-     * Get usage logs for an API key
-     */
-    async getUsage(id, params) {
-        return this.client.get(`/api-keys/${id}/usage`, params);
-    }
-    /**
-     * Get API key analytics (all keys or specific key)
-     */
-    async getAnalyticsEnhanced(apiKeyId, params) {
-        const endpoint = apiKeyId === 'all' ? '/api-keys/analytics' : `/api-keys/${apiKeyId}/analytics`;
-        return this.client.get(endpoint, params);
-    }
-    /**
-     * Get API key usage logs (all keys or specific key)
-     */
-    async getLogs(apiKeyId, params) {
-        const endpoint = apiKeyId === 'all' ? '/api-keys/logs' : `/api-keys/${apiKeyId}/logs`;
-        return this.client.get(endpoint, params);
-    }
-    /**
-     * Get API key permission options
-     */
-    async getPermissionOptions() {
-        return this.client.get('/api-keys/options');
-    }
-    /**
-     * Get API key security logs
-     */
-    async getSecurityLogs(id) {
-        return this.client.get(`/api-keys/${id}/security-logs`);
-    }
-    /**
-     * Update API key security settings
-     */
-    async updateSecurity(id, data) {
-        return this.client.put(`/api-keys/${id}/security`, data);
-    }
-    /**
-     * Clear suspicious activity for API key
-     */
-    async clearSuspiciousActivity(id) {
-        return this.client.post(`/api-keys/${id}/clear-suspicious`);
-    }
-}
-exports.ApiKeysEndpoint = ApiKeysEndpoint;
-/**
- * Model Configurations endpoint handlers
- */
-class ModelConfigsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get available models catalog
-     */
-    async getAvailable() {
-        const response = await this.client.get('/model-configs/available');
-        // Handle both wrapped and direct array responses
-        return Array.isArray(response) ? response : response.data || [];
-    }
-    /**
-     * Get search-capable models (all available, regardless of user configuration)
-     */
-    async getSearchCapable() {
-        const response = await this.client.get('/model-configs/search-capable');
-        return response.data || [];
-    }
-    /**
-     * Get configured search-capable models (only user's configured and enabled models)
-     */
-    async getSearchConfigured() {
-        const response = await this.client.get('/model-configs/search-configured');
-        return response.data || [];
-    }
-    /**
-     * List user's model configurations
-     */
-    async list() {
-        const response = await this.client.get('/model-configs');
-        // Handle both wrapped and direct array responses
-        return Array.isArray(response) ? response : response.data || [];
-    }
-    /**
-     * Create a new model configuration
-     */
-    async create(data) {
-        return this.client.post('/model-configs', data);
-    }
-    /**
-     * Update an existing model configuration
-     */
-    async update(id, data) {
-        return this.client.put(`/model-configs/${id}`, data);
-    }
-    /**
-     * Delete a model configuration
-     */
-    async delete(id) {
-        return this.client.delete(`/model-configs/${id}`);
-    }
-    /**
-     * Enable/disable a model configuration
-     */
-    async updateStatus(id, isEnabled) {
-        return this.client.patch(`/model-configs/${id}/status`, { isEnabled });
-    }
-    /**
-     * Set a model configuration as default
-     */
-    async setDefault(id) {
-        return this.client.patch(`/model-configs/${id}/default`);
-    }
-    /**
-     * Get usage statistics
-     */
-    async getUsage() {
-        return this.client.get('/model-configs/usage');
-    }
-}
-exports.ModelConfigsEndpoint = ModelConfigsEndpoint;
-/**
- * Dispatch endpoint handler for atomic record/flow creation and execution
- */
-class DispatchEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Dispatch: create and/or execute flows on records atomically
-     */
-    async execute(data) {
-        return this.client.post('/dispatch', data);
-    }
-    /**
-     * Dispatch with streaming response
-     */
-    async executeStream(data) {
-        return this.client.requestStream('/dispatch', {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-    /**
-     * Resume paused flow execution
-     * API expects snake_case field names
-     *
-     * @param data.execution_id - The execution ID to resume
-     * @param data.tool_outputs - Tool outputs to inject into the flow
-     * @param data.stream_response - Whether to stream the response
-     * @param data.messages - Optional messages to override the original dispatch messages
-     */
-    async resume(data) {
-        if (data.streamResponse) {
-            return this.client.requestStream('/dispatch/resume', {
-                method: 'POST',
-                body: JSON.stringify(data),
-            });
-        }
-        return this.client.post('/dispatch/resume', data);
-    }
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before redispatch.
-     */
-    gateGeneratedRuntimeToolProposal(proposal, options) {
-        return (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-    }
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal, options) {
-        return (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(proposal, options);
-    }
-    /**
-     * Attach approved runtime tools to a prompt step in a redispatch request.
-     * Returns a new request object and does not mutate the original.
-     */
-    attachApprovedRuntimeTools(request, runtimeTools, options) {
-        return (0, generated_tool_gate_1.attachRuntimeToolsToDispatchRequest)(request, runtimeTools, options);
-    }
-    /**
-     * Validate a generated runtime tool proposal and attach it to the redispatch
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request, proposal, options) {
-        return (0, generated_tool_gate_1.applyGeneratedRuntimeToolProposalToDispatchRequest)(request, proposal, options);
-    }
-}
-exports.DispatchEndpoint = DispatchEndpoint;
-/**
- * Chat endpoint handler
- */
-class ChatEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Send a chat message
-     */
-    async send(message) {
-        return this.client.post('/chat', { message });
-    }
-    /**
-     * Send a chat message with streaming response
-     */
-    async sendStream(message, options) {
-        return this.client.requestStream('/chat', {
-            method: 'POST',
-            body: JSON.stringify({ message, ...options }),
-        });
-    }
-}
-exports.ChatEndpoint = ChatEndpoint;
-/**
- * Users endpoint handlers
- */
-class UsersEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get current user profile
-     */
-    async getProfile() {
-        return this.client.get('/users/profile');
-    }
-    /**
-     * Update user profile
-     */
-    async updateProfile(data) {
-        return this.client.put('/users/profile', data);
-    }
-}
-exports.UsersEndpoint = UsersEndpoint;
-/**
- * Analytics endpoint handlers
- */
-class AnalyticsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get analytics stats
-     */
-    async getStats(params) {
-        return this.client.get('/analytics/stats', params);
-    }
-    /**
-     * Get analytics executions
-     */
-    async getExecutions(params) {
-        return this.client.get('/analytics/record-results', params);
-    }
-    /**
-     * Get all record results (same as executions)
-     */
-    async getAllRecordResults(params) {
-        return this.client.get('/analytics/record-results', params);
-    }
-    /**
-     * Get model usage analytics
-     */
-    async getModelUsage(params) {
-        return this.client.get('/model-usage', params);
-    }
-}
-exports.AnalyticsEndpoint = AnalyticsEndpoint;
-/**
- * Flow Steps endpoint handlers
- *
- * @deprecated Flow steps are now consolidated into the flows endpoint.
- * Use `flows.get(id)` to get a flow with embedded `flowSteps`.
- * Use `flows.update(id, { flow_steps: [...] })` to update flow steps.
- */
-class FlowStepsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get flow steps for a flow
-     * @deprecated Use `flows.get(flowId)` instead - flow steps are now embedded in the flow response as `flowSteps`
-     */
-    async getByFlow(flowId) {
-        console.warn('[Runtype SDK] flowSteps.getByFlow() is deprecated. Use flows.get(flowId) instead - flow steps are now embedded in the flow response as flowSteps.');
-        return this.client.get(`/flow-steps/flow/${flowId}`);
-    }
-    /**
-     * Get a specific flow step
-     * @deprecated Use `flows.get(flowId)` and find the step in `flowSteps` array
-     */
-    async get(id) {
-        console.warn('[Runtype SDK] flowSteps.get() is deprecated. Use flows.get(flowId) and find the step in flowSteps array.');
-        return this.client.get(`/flow-steps/${id}`);
-    }
-    /**
-     * Create a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to add steps
-     */
-    async create(data) {
-        console.warn('[Runtype SDK] flowSteps.create() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) to add steps.');
-        return this.client.post('/flow-steps', data);
-    }
-    /**
-     * Update a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` to update steps
-     */
-    async update(id, data) {
-        console.warn('[Runtype SDK] flowSteps.update() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) to update steps.');
-        return this.client.put(`/flow-steps/${id}`, data);
-    }
-    /**
-     * Delete a flow step
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with the step removed
-     */
-    async delete(id) {
-        console.warn('[Runtype SDK] flowSteps.delete() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) with the step removed.');
-        return this.client.delete(`/flow-steps/${id}`);
-    }
-    /**
-     * Reorder flow steps
-     * @deprecated Use `flows.update(flowId, { flow_steps: [...] })` with updated order values
-     */
-    async reorder(flowId, stepOrders) {
-        console.warn('[Runtype SDK] flowSteps.reorder() is deprecated. Use flows.update(flowId, { flow_steps: [...] }) with updated order values.');
-        return this.client.post('/flow-steps/reorder', {
-            flowId,
-            stepOrders,
-        });
-    }
-}
-exports.FlowStepsEndpoint = FlowStepsEndpoint;
-/**
- * Context Templates endpoint handlers
- */
-class ContextTemplatesEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List context templates
-     */
-    async list(params) {
-        return this.client.get('/context-templates', params);
-    }
-    /**
-     * Get a specific context template
-     */
-    async get(id) {
-        return this.client.get(`/context-templates/${id}`);
-    }
-    /**
-     * Create a context template
-     */
-    async create(data) {
-        return this.client.post('/context-templates', data);
-    }
-    /**
-     * Update a context template
-     */
-    async update(id, data) {
-        return this.client.put(`/context-templates/${id}`, data);
-    }
-    /**
-     * Delete a context template
-     */
-    async delete(id) {
-        return this.client.delete(`/context-templates/${id}`);
-    }
-}
-exports.ContextTemplatesEndpoint = ContextTemplatesEndpoint;
-/**
- * Tools endpoint handlers
- */
-class ToolsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all tools for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/tools', params);
-    }
-    /**
-     * Get a specific tool by ID
-     */
-    async get(id) {
-        return this.client.get(`/tools/${id}`);
-    }
-    /**
-     * Create a new tool
-     */
-    async create(data) {
-        return this.client.post('/tools', data);
-    }
-    /**
-     * Update an existing tool
-     */
-    async update(id, data) {
-        return this.client.put(`/tools/${id}`, data);
-    }
-    /**
-     * Delete a tool
-     */
-    async delete(id) {
-        return this.client.delete(`/tools/${id}`);
-    }
-    /**
-     * Execute a tool
-     */
-    async execute(id, data) {
-        return this.client.post(`/tools/${id}/execute`, data);
-    }
-    /**
-     * Execute a tool with streaming response
-     */
-    async executeStream(id, data) {
-        return this.client.requestStream(`/tools/${id}/execute`, {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-    /**
-     * Test a tool (same as execute but for testing purposes)
-     */
-    async test(id, data) {
-        return this.client.post(`/tools/${id}/test`, data);
-    }
-    /**
-     * Get tool executions for a specific tool
-     */
-    async getExecutions(toolId, params) {
-        return this.client.get(`/tools/${toolId}/executions`, params);
-    }
-    /**
-     * Get AI SDK compatible tool schemas
-     */
-    async getSchemas(params) {
-        return this.client.get('/tools/schema', params);
-    }
-    /**
-     * Get available tools for prompts
-     */
-    async getAvailable() {
-        const response = await this.client.get('/tools', {
-            isActive: true,
-            limit: 200,
-        });
-        const payload = response;
-        if (Array.isArray(payload?.data)) {
-            return payload.data;
-        }
-        if (Array.isArray(payload)) {
-            return payload;
-        }
-        return [];
-    }
-    /**
-     * Convert a flow to a tool
-     */
-    async convertFromFlow(flowId, data) {
-        return this.client.post(`/flows/${flowId}/convert-to-tool`, data);
-    }
-    /**
-     * Get all built-in tools
-     */
-    async getBuiltInTools() {
-        return this.client.get('/tools/builtin');
-    }
-    /**
-     * Get built-in tools compatible with a specific model and provider
-     */
-    async getCompatibleBuiltInTools(model, provider) {
-        return this.client.get('/tools/builtin/compatible', {
-            model,
-            provider,
-        });
-    }
-    /**
-     * Get parameter schema for a specific built-in tool
-     */
-    async getBuiltInToolSchema(toolId) {
-        return this.client.get(`/tools/builtin/${toolId}/schema`);
-    }
-}
-exports.ToolsEndpoint = ToolsEndpoint;
-/**
- * Eval endpoint handlers
- */
-class EvalEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Run virtual eval with streaming response
-     * Executes multiple eval configs simultaneously and streams results via multiplexed SSE
-     */
-    async runVirtualEval(data) {
-        return this.client.requestStream('/eval/stream', {
-            method: 'POST',
-            body: JSON.stringify(data),
-        });
-    }
-}
-exports.EvalEndpoint = EvalEndpoint;
-/**
- * Client Tokens endpoint handlers
- *
- * Manages client tokens for secure browser-to-API communication.
- * Client tokens enable embedding chat widgets in external applications.
- */
-class ClientTokensEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all client tokens for the authenticated user
-     */
-    async list() {
-        const response = await this.client.get('/client-tokens');
-        return response.clientTokens;
-    }
-    /**
-     * Get a specific client token by ID
-     */
-    async get(id) {
-        return this.client.get(`/client-tokens/${id}`);
-    }
-    /**
-     * Create a new client token
-     *
-     * @returns The created token with the plain token value (shown only once)
-     */
-    async create(data) {
-        return this.client.post('/client-tokens', data);
-    }
-    /**
-     * Update an existing client token
-     */
-    async update(id, data) {
-        return this.client.put(`/client-tokens/${id}`, data);
-    }
-    /**
-     * Delete a client token
-     */
-    async delete(id) {
-        return this.client.delete(`/client-tokens/${id}`);
-    }
-    /**
-     * Regenerate a client token's value
-     *
-     * @returns The updated token with the new plain token value (shown only once)
-     */
-    async regenerate(id) {
-        return this.client.post(`/client-tokens/${id}/regenerate`);
-    }
-    /**
-     * Get the plain token value for a client token
-     *
-     * Note: Only works if the token was just created or regenerated in the same session
-     */
-    async getToken(id) {
-        return this.client.get(`/client-tokens/${id}/token`);
-    }
-    /**
-     * List conversations for a client token
-     */
-    async listConversations(id, params) {
-        return this.client.get(`/client-tokens/${id}/conversations`, params);
-    }
-}
-exports.ClientTokensEndpoint = ClientTokensEndpoint;
-/**
- * Parse SSE stream chunks into individual events with event type support
- */
-function parseSSEChunkWithEventType(chunk, buffer) {
-    buffer += chunk;
-    // Split on double newlines to get complete events
-    const parts = buffer.split('\n\n');
-    const remainingBuffer = parts.pop() || '';
-    const events = [];
-    for (const part of parts) {
-        if (!part.trim())
-            continue;
-        const lines = part.split('\n');
-        let eventType = null;
-        let dataStr = null;
-        for (const line of lines) {
-            if (line.startsWith('event: ')) {
-                eventType = line.slice(7).trim();
-            }
-            else if (line.startsWith('data: ')) {
-                dataStr = line.slice(6).trim();
-            }
-        }
-        if (dataStr && dataStr !== '[DONE]') {
-            try {
-                const data = JSON.parse(dataStr);
-                events.push({ eventType, data });
-            }
-            catch {
-                // Invalid JSON, skip
-            }
-        }
-    }
-    return { events, remainingBuffer };
-}
-/**
- * Dispatch a parsed agent event to the appropriate callback
- */
-function dispatchAgentEvent(event, callbacks) {
-    const { eventType, data } = event;
-    const typedData = data;
-    // If no event type, try to get it from the data
-    const type = eventType || typedData?.type;
-    // @snake-case-ok-start: Agent event type identifiers use snake_case to match flow events
-    switch (type) {
-        case 'agent_start':
-            callbacks.onAgentStart?.(typedData);
-            break;
-        case 'agent_iteration_start':
-            callbacks.onIterationStart?.(typedData);
-            break;
-        case 'agent_turn_start':
-            callbacks.onTurnStart?.(typedData);
-            break;
-        case 'agent_turn_delta':
-            callbacks.onTurnDelta?.(typedData);
-            break;
-        case 'agent_turn_complete':
-            callbacks.onTurnComplete?.(typedData);
-            break;
-        case 'agent_tool_start':
-            callbacks.onToolStart?.(typedData);
-            break;
-        case 'agent_tool_delta':
-            callbacks.onToolDelta?.(typedData);
-            break;
-        case 'agent_tool_complete':
-            callbacks.onToolComplete?.(typedData);
-            break;
-        case 'agent_iteration_complete':
-            callbacks.onIterationComplete?.(typedData);
-            break;
-        case 'agent_reflection':
-            callbacks.onReflection?.(typedData);
-            break;
-        case 'agent_complete':
-            callbacks.onAgentComplete?.(typedData);
-            break;
-        case 'agent_error':
-            callbacks.onError?.(typedData);
-            break;
-        case 'agent_await':
-            callbacks.onAgentPaused?.(typedData);
-            break;
-        case 'agent_ping':
-            callbacks.onPing?.(typedData);
-            break;
-        default:
-            callbacks.onUnknownEvent?.(event);
-    }
-    // @snake-case-ok-end
-}
-/**
- * Process agent stream with callbacks
- */
-async function processAgentStream(body, callbacks) {
-    if (!body)
-        return;
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                // Process any remaining buffer
-                if (buffer.trim()) {
-                    const { events } = parseSSEChunkWithEventType(buffer + '\n\n', '');
-                    for (const event of events) {
-                        dispatchAgentEvent(event, callbacks);
-                    }
-                }
-                break;
-            }
-            const chunk = decoder.decode(value, { stream: true });
-            const { events, remainingBuffer } = parseSSEChunkWithEventType(chunk, buffer);
-            buffer = remainingBuffer;
-            for (const event of events) {
-                dispatchAgentEvent(event, callbacks);
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-const GENERATED_RUNTIME_TOOL_PROPOSAL_SCHEMA = {
-    type: 'object',
-    properties: {
-        name: {
-            type: 'string',
-            description: 'Tool name. Use letters/numbers/underscore only.',
-        },
-        description: {
-            type: 'string',
-            description: 'Clear description of what the generated tool does.',
-        },
-        toolType: {
-            type: 'string',
-            enum: ['custom'],
-            description: 'Must be "custom" for generated code execution tools.',
-        },
-        parametersSchema: {
-            type: 'object',
-            description: 'JSON schema for tool call arguments.',
-        },
-        config: {
-            type: 'object',
-            description: 'Runtime tool config including code, sandboxProvider, language, and timeout.',
-        },
-        reason: {
-            type: 'string',
-            description: 'Why this tool is needed.',
-        },
-    },
-    required: ['name', 'description', 'toolType', 'parametersSchema', 'config'],
-};
-function appendRuntimeToolsToAgentRequest(request, runtimeTools) {
-    const existing = request.tools?.runtimeTools || [];
-    const existingNames = new Set(existing.map((tool) => tool.name));
-    const converted = runtimeTools
-        .filter((tool) => !existingNames.has(tool.name))
-        .map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        toolType: tool.toolType,
-        parametersSchema: tool.parametersSchema,
-        ...(tool.config ? { config: tool.config } : {}),
-    }));
-    return {
-        ...request,
-        tools: {
-            ...request.tools,
-            runtimeTools: [...existing, ...converted],
-        },
-    };
-}
-/**
- * Agents endpoint handlers
- */
-class AgentsEndpoint {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all agents for the authenticated user
-     */
-    async list(params) {
-        return this.client.get('/agents', params);
-    }
-    /**
-     * Get a specific agent by ID
-     */
-    async get(id) {
-        return this.client.get(`/agents/${id}`);
-    }
-    /**
-     * Create a new agent
-     */
-    async create(data) {
-        return this.client.post('/agents', data);
-    }
-    /**
-     * Update an existing agent
-     */
-    async update(id, data) {
-        return this.client.put(`/agents/${id}`, data);
-    }
-    /**
-     * Delete an agent
-     */
-    async delete(id) {
-        return this.client.delete(`/agents/${id}`);
-    }
-    /**
-     * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
-     * Useful for local `propose_runtime_tool` handlers before follow-up execution.
-     */
-    gateGeneratedRuntimeToolProposal(proposal, options) {
-        return (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-    }
-    /**
-     * Build standardized local-tool output for a generated tool proposal.
-     * Returns `{ approved, reason, violations, tool? }`.
-     */
-    buildGeneratedRuntimeToolGateOutput(proposal, options) {
-        return (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(proposal, options);
-    }
-    /**
-     * Create a local tool definition that validates model-proposed runtime tools.
-     * Plug this into `executeWithLocalTools()` under a name like `propose_runtime_tool`.
-     */
-    createGeneratedRuntimeToolGateLocalTool(options) {
-        const { description, ...gateOptions } = options || {};
-        return {
-            description: description ||
-                'Validate a generated runtime custom tool and return { approved, reason, violations, tool? }',
-            parametersSchema: GENERATED_RUNTIME_TOOL_PROPOSAL_SCHEMA,
-            execute: async (args) => (0, generated_tool_gate_1.buildGeneratedRuntimeToolGateOutput)(args, gateOptions),
-        };
-    }
-    /**
-     * Attach approved runtime tools to an agent execute request.
-     * Returns a new request object and does not mutate the original.
-     */
-    attachApprovedRuntimeTools(request, runtimeTools) {
-        return appendRuntimeToolsToAgentRequest(request, runtimeTools);
-    }
-    /**
-     * Validate a generated runtime tool proposal and append it to an agent execute
-     * request if approved, in one call.
-     */
-    applyGeneratedRuntimeToolProposal(request, proposal, options) {
-        const decision = (0, generated_tool_gate_1.evaluateGeneratedRuntimeToolProposal)(proposal, options);
-        if (!decision.approved || !decision.tool) {
-            return { decision, request };
-        }
-        return {
-            decision,
-            request: appendRuntimeToolsToAgentRequest(request, [decision.tool]),
-        };
-    }
-    /**
-     * Execute an agent (non-streaming)
-     */
-    async execute(id, data) {
-        return this.client.post(`/agents/${id}/execute`, {
-            ...data,
-            streamResponse: false,
-        });
-    }
-    /**
-     * Execute an agent with streaming response
-     *
-     * Returns a Response object with SSE stream.
-     * Use `executeWithCallbacks` for easier handling.
-     *
-     * @example
-     * ```typescript
-     * const response = await client.agents.executeStream('agt_123', {
-     *   messages: [{ role: 'user', content: 'Write me a poem' }],
-     *   debugMode: true,
-     * })
-     *
-     * // Process the stream manually
-     * const reader = response.body?.getReader()
-     * // ...
-     * ```
-     */
-    async executeStream(id, data) {
-        return this.client.requestStream(`/agents/${id}/execute`, {
-            method: 'POST',
-            body: JSON.stringify({
-                ...data,
-                streamResponse: true,
-            }),
-        });
-    }
-    /**
-     * Execute an agent with streaming and callbacks
-     *
-     * Processes the SSE stream and calls the appropriate callbacks for each event type.
-     * This is the recommended way to handle agent streaming.
-     *
-     * @example
-     * ```typescript
-     * let content = ''
-     *
-     * const result = await client.agents.executeWithCallbacks('agt_123', {
-     *   messages: [{ role: 'user', content: 'Write me a poem' }],
-     *   debugMode: true,
-     * }, {
-     *   onTurnDelta: (event) => {
-     *     content += event.delta
-     *     process.stdout.write(event.delta)
-     *   },
-     *   onIterationComplete: (event) => {
-     *     console.log(`\nIteration ${event.iteration} complete`)
-     *   },
-     *   onAgentComplete: (event) => {
-     *     console.log(`\nAgent finished: ${event.stopReason}`)
-     *   },
-     *   onError: (event) => {
-     *     console.error(`Error: ${event.error.message}`)
-     *   },
-     * })
-     *
-     * console.log('Final result:', result)
-     * ```
-     */
-    async executeWithCallbacks(id, data, callbacks) {
-        const response = await this.executeStream(id, data);
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(error.error || `HTTP ${response.status}`);
-        }
-        let completeEvent = null;
-        // Accumulate turn delta text so finalOutput is non-empty even when the
-        // agent_complete event carries no output (e.g. model ended after tool calls)
-        let accumulatedOutput = '';
-        await processAgentStream(response.body, {
-            ...callbacks,
-            onTurnDelta: (event) => {
-                if (event.contentType === 'text') {
-                    accumulatedOutput += event.delta;
-                }
-                callbacks.onTurnDelta?.(event);
-            },
-            onAgentComplete: (event) => {
-                if (!event.finalOutput && accumulatedOutput) {
-                    event.finalOutput = accumulatedOutput;
-                }
-                completeEvent = event;
-                callbacks.onAgentComplete?.(event);
-            },
-        });
-        return completeEvent;
-    }
-    /**
-     * Execute an agent with local tool support (pause/resume loop)
-     *
-     * When the agent hits a tool with `toolType: 'local'`, the server emits
-     * `agent_await`. This method automatically executes the local tool and
-     * resumes execution, repeating until the agent completes.
-     *
-     * @example
-     * ```typescript
-     * const result = await client.agents.executeWithLocalTools('agt_123', {
-     *   messages: [{ role: 'user', content: 'Create a file called hello.txt' }],
-     * }, {
-     *   write_file: async ({ path, content }) => {
-     *     fs.writeFileSync(path, content)
-     *     return 'ok'
-     *   },
-     * })
-     * ```
-     */
-    async executeWithLocalTools(id, data, localTools, callbacks, options) {
-        // Build runtime tool definitions from local tool schemas and inject into request
-        const runtimeTools = Object.entries(localTools).map(([name, def]) => ({
-            name,
-            description: def.description,
-            toolType: 'local',
-            parametersSchema: def.parametersSchema,
-        }));
-        const requestData = {
-            ...data,
-            tools: {
-                ...data.tools,
-                runtimeTools: [...(data.tools?.runtimeTools || []), ...runtimeTools],
-            },
-        };
-        const response = await this.executeStream(id, requestData);
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(error.error || `HTTP ${response.status}`);
-        }
-        let currentBody = response.body;
-        // Accumulate text output across all streams (initial + resume cycles)
-        // so finalOutput is non-empty even when the last resume stream has no text
-        let accumulatedOutput = '';
-        let pauseCount = 0;
-        let discoveryPauseCount = 0;
-        let consecutiveDiscoveryPauseCount = 0;
-        const toolNameCounts = {};
-        let recentActionKeys = [];
-        while (true) {
-            let pausedEvent = null;
-            let completeEvent = null;
-            await processAgentStream(currentBody, {
-                ...callbacks,
-                onTurnDelta: (event) => {
-                    if (event.contentType === 'text') {
-                        accumulatedOutput += event.delta;
-                    }
-                    callbacks?.onTurnDelta?.(event);
-                },
-                onAgentPaused: (event) => {
-                    pausedEvent = event;
-                    callbacks?.onAgentPaused?.(event);
-                },
-                onAgentComplete: (event) => {
-                    // Supplement finalOutput with accumulated turn deltas when the
-                    // agent_complete event itself carries no output (common when the
-                    // model's last action was a tool call rather than text output)
-                    if (!event.finalOutput && accumulatedOutput) {
-                        event.finalOutput = accumulatedOutput;
-                    }
-                    completeEvent = event;
-                    callbacks?.onAgentComplete?.(event);
-                },
-            });
-            if (completeEvent)
-                return completeEvent;
-            if (pausedEvent) {
-                const { toolName, parameters, executionId } = pausedEvent;
-                const toolDef = localTools[toolName];
-                if (!toolDef) {
-                    throw new Error(`Local tool "${toolName}" required but not provided`);
-                }
-                // Recursively unwrap stringified parameters — the server pipeline may
-                // double-serialize: object → JSON string → JSON string
-                let parsedParams = {};
-                let current = parameters;
-                for (let i = 0; i < 3; i++) {
-                    if (typeof current === 'string') {
-                        try {
-                            current = JSON.parse(current);
-                        }
-                        catch {
-                            console.warn(`[local-tools] Failed to parse parameters (attempt ${i + 1}):`, typeof current, String(current).slice(0, 200));
-                            break;
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-                if (current && typeof current === 'object' && !Array.isArray(current)) {
-                    parsedParams = current;
-                }
-                else {
-                    console.warn('[local-tools] Parameters could not be resolved to an object:', typeof current, String(current).slice(0, 200));
-                }
-                let toolResult;
-                try {
-                    toolResult = await toolDef.execute(parsedParams);
-                }
-                catch (err) {
-                    // Return the error as a tool result so the agent can recover
-                    toolResult = `Error: ${err instanceof Error ? err.message : String(err)}`;
-                }
-                pauseCount += 1;
-                const toolNameCount = (toolNameCounts[toolName] || 0) + 1;
-                toolNameCounts[toolName] = toolNameCount;
-                const discoveryTool = this.isDiscoveryLocalTool(toolName);
-                if (discoveryTool) {
-                    discoveryPauseCount += 1;
-                    consecutiveDiscoveryPauseCount += 1;
-                }
-                else {
-                    consecutiveDiscoveryPauseCount = 0;
-                }
-                const actionKey = this.buildLocalToolActionKey(toolName, parsedParams);
-                recentActionKeys = [...recentActionKeys, actionKey].slice(-12);
-                const actionKeyCount = recentActionKeys.filter((candidateActionKey) => candidateActionKey === actionKey).length;
-                const forcedCompleteEvent = options?.onLocalToolResult?.({
-                    executionId,
-                    pauseCount,
-                    discoveryPauseCount,
-                    consecutiveDiscoveryPauseCount,
-                    toolName,
-                    toolNameCount,
-                    parameters: parsedParams,
-                    toolResult,
-                    accumulatedOutput,
-                    actionKey,
-                    actionKeyCount,
-                    recentActionKeys,
-                });
-                if (forcedCompleteEvent) {
-                    if (!forcedCompleteEvent.finalOutput && accumulatedOutput) {
-                        forcedCompleteEvent.finalOutput = accumulatedOutput;
-                    }
-                    callbacks?.onAgentComplete?.(forcedCompleteEvent);
-                    return forcedCompleteEvent;
-                }
-                // Resume via agent resume endpoint
-                const resumeResponse = await this.client.requestStream(`/agents/${id}/resume`, {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        executionId,
-                        toolOutputs: { [toolName]: toolResult },
-                        streamResponse: true,
-                        debugMode: data.debugMode,
-                    }),
-                });
-                if (!resumeResponse.ok) {
-                    const error = await resumeResponse.json().catch(() => ({ error: 'Unknown error' }));
-                    throw new Error(error.error || `HTTP ${resumeResponse.status}`);
-                }
-                currentBody = resumeResponse.body;
-                continue;
-            }
-            // Stream ended without complete or paused
-            return null;
-        }
-    }
-    // ─── Long-Task Agent Execution ───────────────────────────────────────
-    createEmptyToolTrace() {
-        return {
-            entries: [],
-            discoveryPerformed: false,
-            attemptedWrite: false,
-            wroteFiles: false,
-            executionFileWritten: false,
-            readFiles: false,
-            readPaths: [],
-            actionKeys: [],
-            candidatePaths: [],
-            planWritten: false,
-            bestCandidateReadFailed: false,
-            bestCandidateWritten: false,
-            bestCandidateVerified: false,
-            verificationAttempted: false,
-            verificationPassed: false,
-            localToolLoopGuardTriggered: false,
-        };
-    }
-    isDiscoveryLocalTool(toolName) {
-        return ['tree_directory', 'search_repo', 'glob_files', 'list_directory', 'read_file'].includes(toolName);
-    }
-    buildLocalToolActionKey(toolName, parameters) {
-        const pathValue = typeof parameters.path === 'string' ? this.normalizeCandidatePath(parameters.path) : '';
-        const queryValue = typeof parameters.query === 'string'
-            ? parameters.query.trim()
-            : typeof parameters.q === 'string'
-                ? parameters.q.trim()
-                : '';
-        const patternValue = typeof parameters.pattern === 'string' ? parameters.pattern.trim() : '';
-        const commandValue = typeof parameters.command === 'string' ? parameters.command.trim() : '';
-        const descriptor = pathValue || queryValue || patternValue || commandValue;
-        if (descriptor) {
-            return `${toolName}:${descriptor.slice(0, 160)}`;
-        }
-        const fallback = this.summarizeUnknownForTrace(parameters, 160);
-        return fallback ? `${toolName}:${fallback}` : toolName;
-    }
-    buildProspectiveStateForSessionTrace(state, trace) {
-        const candidatePaths = Array.from(new Set([...(state.candidatePaths || []), ...trace.candidatePaths])).slice(-20);
-        const recentReadPaths = Array.from(new Set([...(state.recentReadPaths || []), ...trace.readPaths])).slice(-20);
-        return {
-            ...state,
-            ...(trace.bestCandidatePath
-                ? {
-                    bestCandidatePath: trace.bestCandidatePath,
-                    bestCandidateReason: trace.bestCandidateReason,
-                }
-                : {}),
-            candidatePaths,
-            recentReadPaths,
-            planWritten: state.planWritten || trace.planWritten,
-        };
-    }
-    buildForcedLocalToolTurnCompleteEvent(state, snapshot, reason) {
-        const finalOutput = [
-            snapshot.accumulatedOutput.trim(),
-            `Local tool loop guard ended this ${state.workflowPhase || 'research'} turn: ${reason}`,
-            snapshot.recentActionKeys.length > 0
-                ? `Recent local tool actions: ${snapshot.recentActionKeys.slice(-5).join(' | ')}`
-                : '',
-        ]
-            .filter(Boolean)
-            .join('\n\n');
-        return {
-            type: 'agent_complete',
-            executionId: snapshot.executionId,
-            seq: 0,
-            agentId: state.agentId,
-            success: true,
-            iterations: 1,
-            stopReason: 'end_turn',
-            completedAt: new Date().toISOString(),
-            totalCost: 0,
-            finalOutput,
-            duration: 0,
-        };
-    }
-    createLocalToolLoopGuard(state, trace) {
-        return (snapshot) => {
-            const repeatedAction = snapshot.actionKeyCount >= 4;
-            const heavyDiscoveryLoop = snapshot.discoveryPauseCount >= 24;
-            const prospectiveState = this.buildProspectiveStateForSessionTrace(state, trace);
-            const sufficientResearch = state.workflowPhase === 'research' && this.hasSufficientResearchEvidence(prospectiveState);
-            let reason;
-            if (state.workflowPhase === 'research') {
-                if (sufficientResearch && snapshot.discoveryPauseCount >= 12) {
-                    reason =
-                        'research evidence is already sufficient, but this execution kept issuing discovery tools instead of ending the turn';
-                }
-                else if (repeatedAction) {
-                    reason = `the same discovery action repeated ${snapshot.actionKeyCount} times in one session`;
-                }
-                else if (snapshot.consecutiveDiscoveryPauseCount >= 18 || heavyDiscoveryLoop) {
-                    reason =
-                        'this session exceeded the discovery-tool budget without ending the turn';
-                }
-            }
-            else if (state.workflowPhase === 'planning' &&
-                !trace.planWritten &&
-                snapshot.consecutiveDiscoveryPauseCount >= 18) {
-                reason = 'planning is looping on discovery instead of writing the plan and ending the turn';
-            }
-            else if (state.workflowPhase === 'execution' &&
-                !trace.executionFileWritten &&
-                snapshot.consecutiveDiscoveryPauseCount >= 18) {
-                reason = 'execution is looping on discovery instead of editing repo files and ending the turn';
-            }
-            if (!reason) {
-                return undefined;
-            }
-            trace.localToolLoopGuardTriggered = true;
-            trace.forcedTurnEndReason = reason;
-            this.pushToolTraceEntry(trace, `local-tool loop guard forced end_turn -> ${reason}`);
-            return this.buildForcedLocalToolTurnCompleteEvent(state, snapshot, reason);
-        };
-    }
-    pushToolTraceEntry(trace, entry) {
-        const trimmed = entry.trim();
-        if (!trimmed)
-            return;
-        if (trace.entries[trace.entries.length - 1] === trimmed)
-            return;
-        trace.entries.push(trimmed);
-        if (trace.entries.length > 12) {
-            trace.entries = trace.entries.slice(-12);
-        }
-    }
-    isPreservationSensitiveTask(state) {
-        const bestCandidatePath = state.bestCandidatePath || '';
-        if (/\.(html|tsx|jsx|css|scss|sass)$/i.test(bestCandidatePath)) {
-            return true;
-        }
-        const prompt = (state.originalMessage || '').toLowerCase();
-        return [
-            'ux',
-            'ui',
-            'design',
-            'frontend',
-            'front-end',
-            'theme',
-            'editor',
-            'layout',
-            'style',
-            'accessibility',
-            'visual',
-        ].some((keyword) => prompt.includes(keyword));
-    }
-    getLikelySupportingCandidatePaths(bestCandidatePath, candidatePaths) {
-        if (!bestCandidatePath || !candidatePaths || candidatePaths.length === 0)
-            return [];
-        const normalizedBestCandidatePath = this.normalizeCandidatePath(bestCandidatePath);
-        const bestCandidateSegments = normalizedBestCandidatePath.split('/').filter(Boolean);
-        const relatedRoot = bestCandidateSegments.length >= 2
-            ? `${bestCandidateSegments[0]}/${bestCandidateSegments[1]}/`
-            : bestCandidateSegments.length === 1
-                ? `${bestCandidateSegments[0]}/`
-                : '';
-        const bestCandidateDir = normalizedBestCandidatePath.includes('/')
-            ? `${normalizedBestCandidatePath.slice(0, normalizedBestCandidatePath.lastIndexOf('/'))}/`
-            : '';
-        return candidatePaths
-            .map((candidatePath) => this.normalizeCandidatePath(candidatePath))
-            .filter((candidatePath) => candidatePath &&
-            candidatePath !== normalizedBestCandidatePath &&
-            !this.isMarathonArtifactPath(candidatePath) &&
-            ((bestCandidateDir && candidatePath.startsWith(bestCandidateDir)) ||
-                (relatedRoot && candidatePath.startsWith(relatedRoot))));
-    }
-    hasSufficientResearchEvidence(state) {
-        if (!state.bestCandidatePath)
-            return false;
-        const normalizedBestCandidatePath = this.normalizeCandidatePath(state.bestCandidatePath);
-        const normalizedRecentReadPaths = (state.recentReadPaths || []).map((readPath) => this.normalizeCandidatePath(readPath));
-        const readBestCandidate = normalizedRecentReadPaths.includes(normalizedBestCandidatePath);
-        if (!readBestCandidate) {
-            return false;
-        }
-        if (!this.isPreservationSensitiveTask(state)) {
-            return true;
-        }
-        const supportingCandidatePaths = this.getLikelySupportingCandidatePaths(state.bestCandidatePath, state.candidatePaths);
-        if (supportingCandidatePaths.length === 0) {
-            return true;
-        }
-        return normalizedRecentReadPaths.some((readPath) => readPath !== normalizedBestCandidatePath && supportingCandidatePaths.includes(readPath));
-    }
-    buildEffectiveSessionOutput(modelOutput, toolTraceSummary) {
-        return [toolTraceSummary.trim(), modelOutput.trim()].filter(Boolean).join('\n\n');
-    }
-    canAcceptTaskCompletion(output, state, sessionTrace) {
-        if (!this.detectTaskCompletion(output)) {
-            return false;
-        }
-        if (state.workflowPhase !== 'execution') {
-            return true;
-        }
-        if (!state.bestCandidatePath) {
-            return true;
-        }
-        const verificationSatisfied = !state.verificationRequired ||
-            Boolean(state.lastVerificationPassed || sessionTrace.verificationPassed);
-        return (Boolean(state.planWritten) &&
-            Boolean(state.bestCandidateVerified || sessionTrace.bestCandidateVerified) &&
-            verificationSatisfied);
-    }
-    summarizeUnknownForTrace(value, maxLength = 180) {
-        const text = typeof value === 'string'
-            ? value
-            : value === undefined
-                ? ''
-                : JSON.stringify(value);
-        return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
-    }
-    summarizeTextBlockForTrace(value, maxLines = 4) {
-        const text = typeof value === 'string'
-            ? value
-            : value === undefined
-                ? ''
-                : JSON.stringify(value);
-        if (!text)
-            return '';
-        return text
-            .split('\n')
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .slice(0, maxLines)
-            .join(' | ')
-            .slice(0, 240);
-    }
-    parseVerificationResult(result) {
-        if (typeof result !== 'string')
-            return undefined;
-        try {
-            const parsed = JSON.parse(result);
-            if (typeof parsed.success !== 'boolean')
-                return undefined;
-            return {
-                success: parsed.success,
-                ...(typeof parsed.command === 'string' ? { command: parsed.command } : {}),
-                ...(typeof parsed.output === 'string' ? { output: parsed.output } : {}),
-                ...(typeof parsed.error === 'string' ? { error: parsed.error } : {}),
-            };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    normalizeCandidatePath(candidatePath) {
-        return candidatePath.trim().replace(/\\/g, '/').replace(/^\.?\//, '').replace(/\/+/g, '/');
-    }
-    dedupeNormalizedCandidatePaths(paths) {
-        return Array.from(new Set((paths || [])
-            .map((candidatePath) => this.normalizeCandidatePath(candidatePath))
-            .filter((candidatePath) => {
-            if (!candidatePath)
-                return false;
-            return !this.isMarathonArtifactPath(candidatePath);
-        })));
-    }
-    isMarathonArtifactPath(candidatePath) {
-        const normalized = this.normalizeCandidatePath(candidatePath).toLowerCase();
-        return normalized === '.runtype' || normalized.startsWith('.runtype/');
-    }
-    isDiscoveryToolName(toolName) {
-        return (toolName === 'search_repo' ||
-            toolName === 'glob_files' ||
-            toolName === 'tree_directory' ||
-            toolName === 'list_directory');
-    }
-    sanitizeTaskSlug(taskName) {
-        return taskName
-            .toLowerCase()
-            .replace(/[^a-z0-9_-]+/g, '-')
-            .replace(/^-+|-+$/g, '')
-            .slice(0, 80);
-    }
-    getDefaultPlanPath(taskName) {
-        const slug = this.sanitizeTaskSlug(taskName || 'task');
-        return `.runtype/marathons/${slug}/plan.md`;
-    }
-    dirnameOfCandidatePath(candidatePath) {
-        const normalized = this.normalizeCandidatePath(candidatePath);
-        const index = normalized.lastIndexOf('/');
-        return index >= 0 ? normalized.slice(0, index) : '';
-    }
-    joinCandidatePath(baseDir, nextPath) {
-        const normalizedNext = nextPath.replace(/\\/g, '/').trim();
-        if (!normalizedNext)
-            return '';
-        if (normalizedNext.startsWith('/')) {
-            return this.normalizeCandidatePath(`${baseDir}/${normalizedNext.slice(1)}`);
-        }
-        if (normalizedNext.startsWith('./')) {
-            return this.normalizeCandidatePath(`${baseDir}/${normalizedNext.slice(2)}`);
-        }
-        return this.normalizeCandidatePath(baseDir ? `${baseDir}/${normalizedNext}` : normalizedNext);
-    }
-    scoreCandidatePath(candidatePath) {
-        const normalized = this.normalizeCandidatePath(candidatePath).toLowerCase();
-        let score = 0;
-        if (normalized.endsWith('/theme.html') || normalized.endsWith('theme.html'))
-            score += 80;
-        if (normalized.includes('agent'))
-            score += 30;
-        if (normalized.includes('editor'))
-            score += 30;
-        if (normalized.includes('theme'))
-            score += 25;
-        if (normalized.endsWith('.html'))
-            score += 20;
-        if (normalized.includes('/src/'))
-            score += 10;
-        if (normalized.includes('/app/'))
-            score += 10;
-        if (normalized.includes('index.html'))
-            score -= 10;
-        return score;
-    }
-    addCandidateToTrace(trace, candidatePath, reason) {
-        const normalized = this.normalizeCandidatePath(candidatePath);
-        if (!normalized || normalized.length < 3)
-            return;
-        if (this.isMarathonArtifactPath(normalized))
-            return;
-        if (!trace.candidatePaths.includes(normalized)) {
-            trace.candidatePaths.push(normalized);
-            if (trace.candidatePaths.length > 12) {
-                trace.candidatePaths = trace.candidatePaths.slice(-12);
-            }
-        }
-        const currentScore = trace.bestCandidatePath ? this.scoreCandidatePath(trace.bestCandidatePath) : -1;
-        const nextScore = this.scoreCandidatePath(normalized);
-        if (!trace.bestCandidatePath || nextScore >= currentScore) {
-            trace.bestCandidatePath = normalized;
-            trace.bestCandidateReason = reason.slice(0, 200);
-        }
-    }
-    extractCandidatePathsFromText(text, sourcePath) {
-        const candidates = [];
-        if (sourcePath && this.isMarathonArtifactPath(sourcePath)) {
-            return candidates;
-        }
-        const add = (candidatePath, reason) => {
-            const normalized = this.normalizeCandidatePath(candidatePath);
-            if (!normalized)
-                return;
-            if (this.isMarathonArtifactPath(normalized))
-                return;
-            if (!candidates.some((candidate) => candidate.path === normalized)) {
-                candidates.push({ path: normalized, reason });
-            }
-        };
-        const baseDir = sourcePath ? this.dirnameOfCandidatePath(sourcePath) : '';
-        for (const match of text.matchAll(/(?:href|src)=["']([^"']+\.(?:html|tsx|ts|jsx|js|md|json))["']/gi)) {
-            const target = match[1] || '';
-            const resolved = baseDir ? this.joinCandidatePath(baseDir, target) : target;
-            add(resolved, `linked from ${sourcePath || 'discovery result'} via ${target}`);
-        }
-        for (const match of text.matchAll(/\b([\w./-]+\.(?:html|tsx|ts|jsx|js|md|json))\b/g)) {
-            const target = match[1] || '';
-            const resolved = sourcePath && !target.includes('/') ? this.joinCandidatePath(baseDir, target) : this.normalizeCandidatePath(target);
-            add(resolved, `mentioned in ${sourcePath || 'discovery result'}`);
-        }
-        return candidates;
-    }
-    parseSearchRepoResultForCandidates(result) {
-        const candidates = [];
-        for (const line of result.split('\n')) {
-            const contentMatch = line.match(/^\[content\]\s+([^:]+):\d+:\s+(.*)$/);
-            if (contentMatch) {
-                const sourcePath = this.normalizeCandidatePath(contentMatch[1] || '');
-                const content = contentMatch[2] || '';
-                for (const candidate of this.extractCandidatePathsFromText(content, sourcePath)) {
-                    if (!candidates.some((existing) => existing.path === candidate.path)) {
-                        candidates.push(candidate);
-                    }
-                }
-                continue;
-            }
-            const pathMatch = line.match(/^\[path\]\s+(.+)$/);
-            if (pathMatch) {
-                const sourcePath = this.normalizeCandidatePath(pathMatch[1] || '');
-                if (/\.(html|tsx|ts|jsx|js|md|json)$/i.test(sourcePath)) {
-                    candidates.push({ path: sourcePath, reason: 'matched repository path search result' });
-                }
-            }
-        }
-        return candidates;
-    }
-    extractBestCandidateFromBootstrapContext(bootstrapContext) {
-        if (!bootstrapContext)
-            return undefined;
-        const candidates = this.parseSearchRepoResultForCandidates(bootstrapContext);
-        if (candidates.length === 0)
-            return undefined;
-        return candidates.sort((a, b) => this.scoreCandidatePath(b.path) - this.scoreCandidatePath(a.path))[0];
-    }
-    sanitizeResumeState(resumeState, taskName) {
-        if (!resumeState)
-            return undefined;
-        const planPath = typeof resumeState.planPath === 'string' && resumeState.planPath.trim()
-            ? this.normalizeCandidatePath(resumeState.planPath)
-            : this.getDefaultPlanPath(taskName);
-        const candidatePaths = this.dedupeNormalizedCandidatePaths(resumeState.candidatePaths);
-        const recentReadPaths = this.dedupeNormalizedCandidatePaths(resumeState.recentReadPaths);
-        const normalizedBestCandidatePath = typeof resumeState.bestCandidatePath === 'string' && resumeState.bestCandidatePath.trim()
-            ? this.normalizeCandidatePath(resumeState.bestCandidatePath)
-            : undefined;
-        const bestCandidatePath = normalizedBestCandidatePath && !this.isMarathonArtifactPath(normalizedBestCandidatePath)
-            ? normalizedBestCandidatePath
-            : [...candidatePaths, ...recentReadPaths].sort((left, right) => this.scoreCandidatePath(right) - this.scoreCandidatePath(left))[0];
-        const workflowPhase = resumeState.planWritten &&
-            (!resumeState.workflowPhase ||
-                resumeState.workflowPhase === 'research' ||
-                resumeState.workflowPhase === 'planning')
-            ? 'execution'
-            : resumeState.workflowPhase;
-        return {
-            ...resumeState,
-            workflowPhase,
-            planPath,
-            planWritten: Boolean(resumeState.planWritten),
-            bestCandidatePath,
-            bestCandidateReason: bestCandidatePath ? resumeState.bestCandidateReason : undefined,
-            candidatePaths,
-            recentReadPaths,
-            recentActionKeys: Array.from(new Set(resumeState.recentActionKeys || [])).slice(-20),
-            bestCandidateNeedsVerification: Boolean(resumeState.bestCandidateNeedsVerification),
-            bestCandidateVerified: Boolean(resumeState.bestCandidateVerified),
-            ...(resumeState.verificationRequired !== undefined
-                ? { verificationRequired: resumeState.verificationRequired }
-                : {}),
-            lastVerificationPassed: Boolean(resumeState.lastVerificationPassed),
-        };
-    }
-    buildPhaseInstructions(state) {
-        const phase = state.workflowPhase || 'research';
-        const planPath = state.planPath || this.getDefaultPlanPath(state.taskName);
-        if (phase === 'planning') {
-            return [
-                '--- Workflow Phase: Planning ---',
-                'Research is complete. Your current job is to write the implementation plan before any product-file edits.',
-                `Write the plan markdown to exactly: ${planPath}`,
-                'Do NOT edit the target product file yet.',
-                'The plan should summarize UX findings, explain why the current best candidate is the right file, and list concrete execution steps.',
-                'The plan must include a "Preserve existing functionality" section that lists current behaviors, linked files, integrations, and constraints that must keep working.',
-                'The plan must include a "Verification steps" section listing the concrete checks you will run before TASK_COMPLETE.',
-                'If the plan already exists, update that same plan file instead of creating a different one.',
-            ].join('\n');
-        }
-        if (phase === 'execution') {
-            return [
-                '--- Workflow Phase: Execution ---',
-                `The plan should already exist at: ${planPath}`,
-                ...(state.bestCandidatePath ? [`Primary target file: ${state.bestCandidatePath}`] : []),
-                'Execute the plan by editing the target files.',
-                'Before ending each turn, update the markdown plan with progress against the steps you completed.',
-                'Modify the existing implementation incrementally. Do not replace the whole file unless the user explicitly asked for a rewrite.',
-                'Preserve existing functionality, handlers, imports, routes, configuration, and data flow unless the plan explicitly calls for changing them.',
-                'Before TASK_COMPLETE, run a verification command that matches the repo, such as lint, tests, build, or typecheck.',
-                'Avoid broad repo discovery unless the current candidate is clearly wrong.',
-            ].join('\n');
-        }
-        return [
-            '--- Workflow Phase: Research ---',
-            'Your current job is to inspect the repo, identify the correct existing target file, and gather enough evidence for a plan.',
-            'Identify related supporting files and current behaviors that must be preserved before planning.',
-            'Do NOT edit the target product file yet.',
-            `When research is complete, the system will advance you to planning and require a plan at: ${planPath}`,
-        ].join('\n');
-    }
-    updateWorkflowPhase(state, sessionTrace) {
-        if (!state.workflowPhase)
-            state.workflowPhase = 'research';
-        if (!state.planPath)
-            state.planPath = this.getDefaultPlanPath(state.taskName);
-        state.phaseTransitionSummary = undefined;
-        const transitionSummaries = [];
-        let phaseUpdated = true;
-        while (phaseUpdated) {
-            phaseUpdated = false;
-            if (state.workflowPhase === 'research' && this.hasSufficientResearchEvidence(state)) {
-                state.workflowPhase = 'planning';
-                transitionSummaries.push([
-                    'Automatic phase transition: research -> planning.',
-                    `Best candidate confirmed: ${state.bestCandidatePath}`,
-                    `Next step: write the plan markdown to ${state.planPath} before editing the product file.`,
-                ].join('\n'));
-                phaseUpdated = true;
-                continue;
-            }
-            if (state.workflowPhase === 'planning' && (sessionTrace.planWritten || state.planWritten)) {
-                state.planWritten = true;
-                state.workflowPhase = 'execution';
-                transitionSummaries.push([
-                    'Automatic phase transition: planning -> execution.',
-                    `Plan path: ${state.planPath}`,
-                    ...(state.bestCandidatePath ? [`Execute against: ${state.bestCandidatePath}`] : []),
-                    'Next step: edit the target file(s) and update the plan with progress each turn.',
-                ].join('\n'));
-                phaseUpdated = true;
-            }
-        }
-        if (state.status === 'complete') {
-            state.workflowPhase = 'complete';
-        }
-        if (transitionSummaries.length > 0) {
-            state.phaseTransitionSummary = transitionSummaries.join('\n\n');
-        }
-    }
-    wrapLocalToolsForTrace(localTools, trace, state) {
-        if (!localTools)
-            return undefined;
-        const wrapped = {};
-        for (const [toolName, toolDef] of Object.entries(localTools)) {
-            wrapped[toolName] = {
-                ...toolDef,
-                execute: async (args) => {
-                    const actionKey = `${toolName}:${String(args.path || args.query || args.pattern || '.').slice(0, 120)}`;
-                    trace.actionKeys.push(actionKey);
-                    if (trace.actionKeys.length > 10) {
-                        trace.actionKeys = trace.actionKeys.slice(-10);
-                    }
-                    const normalizedPathArg = typeof args.path === 'string' && args.path.trim()
-                        ? this.normalizeCandidatePath(String(args.path))
-                        : undefined;
-                    const normalizedPlanPath = state.planPath
-                        ? this.normalizeCandidatePath(state.planPath)
-                        : undefined;
-                    const normalizedBestCandidatePath = state.bestCandidatePath
-                        ? this.normalizeCandidatePath(state.bestCandidatePath)
-                        : undefined;
-                    const allowedWriteTargets = new Set([
-                        normalizedPlanPath,
-                        normalizedBestCandidatePath,
-                        ...(state.recentReadPaths || []).map((readPath) => this.normalizeCandidatePath(readPath)),
-                        ...trace.readPaths.map((readPath) => this.normalizeCandidatePath(readPath)),
-                    ].filter((value) => Boolean(value)));
-                    const pathArg = typeof args.path === 'string' && args.path.trim() ? ` path=${String(args.path)}` : '';
-                    const queryArg = typeof args.query === 'string' && args.query.trim() ? ` query="${String(args.query)}"` : '';
-                    const patternArg = typeof args.pattern === 'string' && args.pattern.trim()
-                        ? ` pattern="${String(args.pattern)}"`
-                        : '';
-                    const isWriteLikeTool = toolName === 'write_file' || toolName === 'restore_file_checkpoint';
-                    const isVerificationTool = toolName === 'run_check';
-                    if (state.workflowPhase === 'execution' &&
-                        normalizedBestCandidatePath &&
-                        this.isDiscoveryToolName(toolName) &&
-                        !trace.bestCandidateReadFailed) {
-                        const blockedMessage = [
-                            `Blocked by marathon execution guard: ${toolName} is disabled during execution.`,
-                            `Read or edit "${normalizedBestCandidatePath}" instead.`,
-                            'Broad discovery is only re-enabled if a read of the current target file fails.',
-                        ].join(' ');
-                        this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg} -> ${blockedMessage}`);
-                        return blockedMessage;
-                    }
-                    if (isWriteLikeTool) {
-                        trace.attemptedWrite = true;
-                        if (state.workflowPhase === 'planning' &&
-                            normalizedPathArg &&
-                            normalizedPlanPath &&
-                            normalizedPathArg !== normalizedPlanPath) {
-                            const blockedMessage = [
-                                `Blocked by marathon planning guard: ${toolName} must target the exact plan path during planning.`,
-                                `Write the plan to "${normalizedPlanPath}" before editing any product files.`,
-                            ].join(' ');
-                            this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg} -> ${blockedMessage}`);
-                            return blockedMessage;
-                        }
-                        if (state.workflowPhase === 'execution' &&
-                            normalizedPathArg &&
-                            normalizedPlanPath &&
-                            normalizedBestCandidatePath &&
-                            normalizedPathArg === normalizedPlanPath &&
-                            !trace.executionFileWritten) {
-                            const blockedMessage = [
-                                `Blocked by marathon execution guard: ${toolName} cannot update the plan file before any real repo-file edit in this execution turn.`,
-                                `Edit "${normalizedBestCandidatePath}" or another previously discovered repo file first.`,
-                                `After that, you may update "${normalizedPlanPath}" with progress.`,
-                            ].join(' ');
-                            this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg} -> ${blockedMessage}`);
-                            return blockedMessage;
-                        }
-                        if (state.workflowPhase === 'execution' &&
-                            normalizedPathArg &&
-                            normalizedPathArg !== normalizedPlanPath &&
-                            !allowedWriteTargets.has(normalizedPathArg)) {
-                            const blockedMessage = [
-                                `Blocked by marathon execution guard: ${toolName} is limited to the confirmed target, the plan file, or files already discovered/read for this task.`,
-                                `Do not create scratch files like "${normalizedPathArg}".`,
-                                normalizedBestCandidatePath
-                                    ? `Edit "${normalizedBestCandidatePath}" or another previously discovered repo file instead.`
-                                    : 'Read the current target file before writing.',
-                            ].join(' ');
-                            this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg} -> ${blockedMessage}`);
-                            return blockedMessage;
-                        }
-                    }
-                    if (this.isDiscoveryToolName(toolName)) {
-                        trace.discoveryPerformed = true;
-                    }
-                    if (toolName === 'read_file') {
-                        trace.readFiles = true;
-                        if (normalizedPathArg) {
-                            const normalizedReadPath = normalizedPathArg;
-                            trace.readPaths.push(normalizedReadPath);
-                            if (trace.readPaths.length > 12) {
-                                trace.readPaths = trace.readPaths.slice(-12);
-                            }
-                            this.addCandidateToTrace(trace, normalizedReadPath, 'explicitly read by agent');
-                        }
-                    }
-                    let result;
-                    try {
-                        result = await toolDef.execute(args);
-                    }
-                    catch (error) {
-                        if (toolName === 'read_file' &&
-                            normalizedPathArg &&
-                            normalizedBestCandidatePath &&
-                            normalizedPathArg === normalizedBestCandidatePath) {
-                            trace.bestCandidateReadFailed = true;
-                        }
-                        this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg} -> error: ${error instanceof Error ? error.message : String(error)}`);
-                        throw error;
-                    }
-                    if (isWriteLikeTool && normalizedPathArg) {
-                        trace.wroteFiles = true;
-                        if (normalizedPlanPath && normalizedPathArg === normalizedPlanPath) {
-                            trace.planWritten = true;
-                        }
-                        else if (state.workflowPhase === 'execution') {
-                            trace.executionFileWritten = true;
-                            trace.verificationPassed = false;
-                            if (normalizedBestCandidatePath &&
-                                normalizedPathArg === normalizedBestCandidatePath) {
-                                trace.bestCandidateWritten = true;
-                            }
-                        }
-                    }
-                    const verificationResult = isVerificationTool
-                        ? this.parseVerificationResult(result)
-                        : undefined;
-                    if (verificationResult) {
-                        trace.verificationAttempted = true;
-                        trace.verificationPassed = verificationResult.success;
-                    }
-                    const summarizedResult = verificationResult
-                        ? [
-                            verificationResult.command || 'verification',
-                            verificationResult.success ? 'passed' : 'failed',
-                            verificationResult.error || verificationResult.output,
-                        ]
-                            .filter(Boolean)
-                            .join(' | ')
-                            .slice(0, 240)
-                        : this.summarizeTextBlockForTrace(result);
-                    const resultSuffix = summarizedResult ? ` -> ${summarizedResult}` : '';
-                    this.pushToolTraceEntry(trace, `${toolName}${pathArg}${queryArg}${patternArg}${resultSuffix}`);
-                    const textResult = typeof result === 'string' ? result : '';
-                    if (toolName === 'read_file' &&
-                        normalizedPathArg &&
-                        normalizedBestCandidatePath &&
-                        normalizedPathArg === normalizedBestCandidatePath &&
-                        (trace.bestCandidateWritten || state.bestCandidateNeedsVerification)) {
-                        trace.bestCandidateVerified = true;
-                    }
-                    if (toolName === 'search_repo' && textResult) {
-                        for (const candidate of this.parseSearchRepoResultForCandidates(textResult)) {
-                            this.addCandidateToTrace(trace, candidate.path, candidate.reason);
-                        }
-                    }
-                    else if (toolName === 'glob_files' && textResult) {
-                        for (const line of textResult.split('\n')) {
-                            const candidatePath = line.trim();
-                            if (/\.(html|tsx|ts|jsx|js|md|json)$/i.test(candidatePath)) {
-                                this.addCandidateToTrace(trace, candidatePath, 'matched glob search');
-                            }
-                        }
-                    }
-                    else if (toolName === 'list_directory' && textResult && typeof args.path === 'string') {
-                        const baseDir = this.normalizeCandidatePath(String(args.path));
-                        for (const line of textResult.split('\n')) {
-                            const candidateName = line.trim();
-                            if (/\.(html|tsx|ts|jsx|js|md|json)$/i.test(candidateName)) {
-                                this.addCandidateToTrace(trace, this.joinCandidatePath(baseDir, candidateName), `listed in directory ${baseDir || '.'}`);
-                            }
-                        }
-                    }
-                    else if (toolName === 'read_file' && textResult && typeof args.path === 'string') {
-                        const sourcePath = this.normalizeCandidatePath(String(args.path));
-                        for (const candidate of this.extractCandidatePathsFromText(textResult, sourcePath)) {
-                            this.addCandidateToTrace(trace, candidate.path, candidate.reason);
-                        }
-                    }
-                    return result;
-                },
-            };
-        }
-        return wrapped;
-    }
-    createTraceCallbacks(callbacks, trace) {
-        if (!callbacks) {
-            return {
-                onToolStart: (event) => {
-                    trace.actionKeys.push(`server:${event.toolName}`);
-                    if (trace.actionKeys.length > 10)
-                        trace.actionKeys = trace.actionKeys.slice(-10);
-                    if (event.toolName === 'write_file')
-                        trace.attemptedWrite = true;
-                    this.pushToolTraceEntry(trace, `server-tool ${event.toolName} started`);
-                },
-                onToolComplete: (event) => {
-                    const resultSummary = this.summarizeTextBlockForTrace(event.result);
-                    this.pushToolTraceEntry(trace, `server-tool ${event.toolName} ${event.success ? 'completed' : 'failed'}${resultSummary ? ` -> ${resultSummary}` : ''}`);
-                },
-            };
-        }
-        return {
-            ...callbacks,
-            onToolStart: (event) => {
-                trace.actionKeys.push(`server:${event.toolName}`);
-                if (trace.actionKeys.length > 10)
-                    trace.actionKeys = trace.actionKeys.slice(-10);
-                if (event.toolName === 'write_file')
-                    trace.attemptedWrite = true;
-                this.pushToolTraceEntry(trace, `server-tool ${event.toolName} started`);
-                callbacks.onToolStart?.(event);
-            },
-            onToolComplete: (event) => {
-                const resultSummary = this.summarizeTextBlockForTrace(event.result);
-                this.pushToolTraceEntry(trace, `server-tool ${event.toolName} ${event.success ? 'completed' : 'failed'}${resultSummary ? ` -> ${resultSummary}` : ''}`);
-                callbacks.onToolComplete?.(event);
-            },
-        };
-    }
-    buildToolTraceSummary(trace) {
-        if (trace.entries.length === 0)
-            return '';
-        const lines = trace.entries.slice(-6).map((entry) => `- ${entry}`);
-        const flags = [];
-        if (trace.discoveryPerformed)
-            flags.push('repo discovery used');
-        if (trace.readFiles)
-            flags.push('candidate files read');
-        if (trace.wroteFiles)
-            flags.push('files written');
-        if (trace.localToolLoopGuardTriggered)
-            flags.push('local-tool loop guard forced end_turn');
-        if (trace.bestCandidateVerified)
-            flags.push('target re-read after write');
-        if (trace.verificationPassed)
-            flags.push('verification passed');
-        else if (trace.verificationAttempted)
-            flags.push('verification failed');
-        return [
-            'Session working memory:',
-            ...(flags.length > 0 ? [`- ${flags.join('; ')}`] : []),
-            ...(trace.bestCandidatePath
-                ? [`- best candidate: ${trace.bestCandidatePath}${trace.bestCandidateReason ? ` (${trace.bestCandidateReason})` : ''}`]
-                : []),
-            ...lines,
-        ]
-            .join('\n')
-            .slice(0, 1200);
-    }
-    extractBootstrapQueries(message) {
-        const queries = [];
-        const noisyTerms = new Set([
-            'a',
-            'against',
-            'all',
-            'analyze',
-            'and',
-            'as',
-            'at',
-            'based',
-            'before',
-            'best',
-            'by',
-            'codebase',
-            'do',
-            'exactly',
-            'files',
-            'first',
-            'following',
-            'goal',
-            'go',
-            'how',
-            'in',
-            'is',
-            'it',
-            'its',
-            'make',
-            'markdown',
-            'most',
-            'no',
-            'of',
-            'on',
-            'order',
-            'plan',
-            'progress',
-            'repo',
-            'research',
-            'right',
-            'save',
-            'session',
-            'solve',
-            'task',
-            'that',
-            'the',
-            'then',
-            'through',
-            'to',
-            'turn',
-            'update',
-            'user',
-            'ux',
-            'web',
-            'when',
-            'with',
-            'work',
-            'your',
-        ]);
-        const push = (candidate) => {
-            const normalized = candidate
-                .replace(/^[^a-z0-9/._-]+|[^a-z0-9/._ -]+$/gi, '')
-                .replace(/\s+/g, ' ')
-                .trim();
-            if (!normalized || normalized.length < 3 || normalized.length > 60)
-                return;
-            const words = normalized.toLowerCase().split(' ').filter(Boolean);
-            if (words.length > 4)
-                return;
-            if (words.every((word) => noisyTerms.has(word)))
-                return;
-            if (words.length > 1 && noisyTerms.has(words[words.length - 1] || ''))
-                return;
-            if (!queries.some((existing) => existing.toLowerCase() === normalized.toLowerCase())) {
-                queries.push(normalized);
-            }
-        };
-        const lowerMessage = message.toLowerCase();
-        const phraseHints = [
-            'agent editor',
-            'theme.html',
-            '/theme.html',
-            'style it visually',
-        ];
-        for (const hint of phraseHints) {
-            if (lowerMessage.includes(hint.toLowerCase()))
-                push(hint);
-        }
-        for (const match of message.matchAll(/"([^"]{3,60})"/g)) {
-            push(match[1] || '');
-        }
-        for (const match of message.matchAll(/(?:go through|review|inspect|edit|improve|update|fix|modify)\s+(?:the\s+)?([a-z0-9][a-z0-9/_-]*(?:\s+[a-z0-9][a-z0-9/_-]*){0,2})/gi)) {
-            push(match[1] || '');
-        }
-        for (const match of message.matchAll(/([a-z0-9][a-z0-9/_-]*(?:\s+[a-z0-9][a-z0-9/_-]*){0,2})\s+(?:page|editor|screen|view|route|component)\b/gi)) {
-            push(match[0] || '');
-            push(match[1] || '');
-        }
-        for (const match of message.matchAll(/\b[\w./-]+\.(?:html|tsx|ts|jsx|js|md|json)\b/g)) {
-            push(match[0] || '');
-        }
-        for (const match of message.matchAll(/\/[A-Za-z0-9._/-]+/g)) {
-            push(match[0] || '');
-        }
-        for (const match of message.matchAll(/\b([a-z0-9]+(?:\s+[a-z0-9]+){1,2})\b/gi)) {
-            const phrase = (match[1] || '').toLowerCase();
-            const words = phrase.split(' ');
-            if (words.some((word) => ['editor', 'page', 'screen', 'view', 'route', 'component'].includes(word))) {
-                push(match[1] || '');
-            }
-        }
-        return queries.slice(0, 4);
-    }
-    async generateBootstrapDiscoveryContext(message, localTools) {
-        if (!localTools)
-            return undefined;
-        const searchTool = localTools.search_repo;
-        const globTool = localTools.glob_files;
-        if (!searchTool && !globTool)
-            return undefined;
-        const queries = this.extractBootstrapQueries(message);
-        if (queries.length === 0)
-            return undefined;
-        const lines = [];
-        for (const query of queries) {
-            if (lines.length >= 6)
-                break;
-            if (searchTool) {
-                try {
-                    const result = await searchTool.execute({ query, path: '.', maxResults: 5 });
-                    const summary = this.summarizeTextBlockForTrace(result, 3);
-                    if (summary && !summary.startsWith('No matches found')) {
-                        lines.push(`search_repo "${query}": ${summary}`);
-                        continue;
-                    }
-                }
-                catch {
-                    // Best effort bootstrap only
-                }
-            }
-            if (globTool && /\./.test(query)) {
-                try {
-                    const result = await globTool.execute({ pattern: `**/${query}`, path: '.', maxResults: 5 });
-                    const summary = this.summarizeTextBlockForTrace(result, 3);
-                    if (summary && !summary.startsWith('No files matched')) {
-                        lines.push(`glob_files "**/${query}": ${summary}`);
-                    }
-                }
-                catch {
-                    // Best effort bootstrap only
-                }
-            }
-        }
-        if (lines.length === 0)
-            return undefined;
-        return ['Bootstrap repo hints:', ...lines].join('\n').slice(0, 1500);
-    }
-    buildStuckTurnRecoveryMessage(state) {
-        const recent = state.sessions.slice(-2);
-        const normalizedPlanPath = typeof state.planPath === 'string' && state.planPath.trim()
-            ? this.normalizeCandidatePath(state.planPath)
-            : undefined;
-        const recentPlanOnlyLoop = Boolean(normalizedPlanPath) &&
-            recent.length === 2 &&
-            recent.every((session) => {
-                const specificActionKeys = (session.actionKeys || [])
-                    .map((actionKey) => actionKey.replace(/\\/g, '/'))
-                    .filter((actionKey) => !actionKey.startsWith('server:'));
-                return (specificActionKeys.length > 0 &&
-                    specificActionKeys.every((actionKey) => actionKey.includes(normalizedPlanPath)));
-            });
-        if (recent.length < 2 ||
-            !(recent.every((session) => session.hadTextOutput === false && session.wroteFiles === false) ||
-                recentPlanOnlyLoop)) {
-            return undefined;
-        }
-        const repeatedSameActions = recent.length === 2 &&
-            recent.every((session) => (session.actionKeys?.length || 0) > 0) &&
-            JSON.stringify(recent[0]?.actionKeys || []) === JSON.stringify(recent[1]?.actionKeys || []);
-        if (state.workflowPhase === 'planning' && state.planPath) {
-            return [
-                'Recovery instruction:',
-                'Research is already complete. Stop rediscovering and write the plan now.',
-                `Your next action must be write_file to "${state.planPath}".`,
-                'The plan must summarize UX findings, include a "Preserve existing functionality" section, name the best candidate file, and list execution steps.',
-                'Do not edit the product file until the plan exists.',
-                ...(repeatedSameActions
-                    ? ['You are repeating the same discovery actions; break the loop by writing the plan file now.']
-                    : []),
-            ].join('\n');
-        }
-        if (state.workflowPhase === 'execution' && state.bestCandidatePath) {
-            const normalizedBestCandidatePath = this.normalizeCandidatePath(state.bestCandidatePath);
-            const recentlyReadBestCandidate = (state.recentReadPaths || [])
-                .map((readPath) => this.normalizeCandidatePath(readPath))
-                .includes(normalizedBestCandidatePath);
-            return [
-                'Recovery instruction:',
-                'Planning should already be complete. Stop rediscovering and execute the plan.',
-                recentlyReadBestCandidate
-                    ? `Your next action must be write_file on "${state.bestCandidatePath}".`
-                    : `Your next action must be read_file on "${state.bestCandidatePath}" so you can edit it next.`,
-                ...(state.planPath
-                    ? [`Do not write "${state.planPath}" again until after you complete a real repo-file edit in this session.`]
-                    : []),
-                'After editing, run a verification command with run_check before TASK_COMPLETE.',
-                'Do not call broad discovery tools again unless the target file is missing or invalid.',
-                ...(repeatedSameActions
-                    ? ['You are repeating the same discovery actions; break the loop by editing the target file now.']
-                    : []),
-            ].join('\n');
-        }
-        if (state.bestCandidatePath) {
-            const recentlyReadBestCandidate = (state.recentReadPaths || []).includes(state.bestCandidatePath);
-            return [
-                'Recovery instruction:',
-                'Your previous sessions produced no final text and did not complete a useful edit.',
-                `You already have a best candidate file: "${state.bestCandidatePath}".`,
-                ...(state.bestCandidateReason ? [`Reason: ${state.bestCandidateReason}`] : []),
-                recentlyReadBestCandidate
-                    ? `Do not keep searching. Your next action must be to edit "${state.bestCandidatePath}" with write_file, or explain why that file is not the correct target.`
-                    : `Do not keep searching. Your next action must be read_file on "${state.bestCandidatePath}".`,
-                'Do not call list_directory, tree_directory, glob_files, or search_repo again unless that candidate path is missing or clearly wrong.',
-                ...(repeatedSameActions
-                    ? ['You are repeating the same discovery actions; break the loop by acting on the best candidate now.']
-                    : []),
-            ].join('\n');
-        }
-        const queries = this.extractBootstrapQueries(state.originalMessage || '');
-        const queryHint = queries.length > 0
-            ? `Start with these exact repo searches: ${queries.map((query) => `"${query}"`).join(', ')}.`
-            : 'Start with a concrete repo search using the key nouns from the original task.';
-        return [
-            'Recovery instruction:',
-            'Your previous sessions produced no final text and did not edit files.',
-            queryHint,
-            'Then read the most relevant existing file you find before any write_file call.',
-            'If a route, link, or page already exists, edit that existing file instead of creating a new one.',
-            ...(repeatedSameActions
-                ? ['You are repeating the same discovery actions; pick one candidate and act on it.']
-                : []),
-        ].join('\n');
-    }
-    /**
-     * Run a long-task agent across multiple sessions with automatic state management.
-     *
-     * Each session is a single agent execution. The SDK drives the loop client-side,
-     * calling the agent's execute endpoint repeatedly and accumulating context.
-     * Progress is optionally synced to a Runtype record for dashboard visibility.
-     *
-     * @example
-     * ```typescript
-     * const result = await client.agents.runTask('agt_123', {
-     *   message: 'Build a REST API with CRUD endpoints',
-     *   maxSessions: 20,
-     *   maxCost: 5.00,
-     *   trackProgress: true,
-     *   onSession: (state) => {
-     *     console.log(`Session ${state.sessionCount}: ${state.lastStopReason} ($${state.totalCost.toFixed(4)})`)
-     *   },
-     * })
-     *
-     * console.log(`Finished: ${result.status} after ${result.sessionCount} sessions`)
-     * ```
-     */
-    async runTask(id, options) {
-        const maxSessions = options.maxSessions ?? 50;
-        const maxCost = options.maxCost;
-        const useStream = options.stream ?? true;
-        // Resolve agent metadata
-        const agent = await this.get(id);
-        const taskName = typeof options.trackProgress === 'string'
-            ? options.trackProgress
-            : options.trackProgress
-                ? `${agent.name} task`
-                : '';
-        const resolvedTaskName = taskName || `${agent.name} task`;
-        const seededResumeState = this.sanitizeResumeState(options.resumeState, resolvedTaskName);
-        // Initialize state
-        const state = {
-            agentId: id,
-            agentName: agent.name,
-            taskName: resolvedTaskName,
-            status: 'running',
-            workflowPhase: seededResumeState?.workflowPhase || 'research',
-            planPath: seededResumeState?.planPath || this.getDefaultPlanPath(resolvedTaskName),
-            planWritten: seededResumeState?.planWritten || false,
-            bestCandidateNeedsVerification: seededResumeState?.bestCandidateNeedsVerification || false,
-            bestCandidateVerified: seededResumeState?.bestCandidateVerified || false,
-            verificationRequired: seededResumeState?.verificationRequired ?? Boolean(options.localTools?.run_check),
-            lastVerificationPassed: seededResumeState?.lastVerificationPassed || false,
-            sessionCount: 0,
-            totalCost: 0,
-            lastOutput: '',
-            lastStopReason: 'complete',
-            sessions: [],
-            startedAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            ...(seededResumeState?.originalMessage ? { originalMessage: seededResumeState.originalMessage } : {}),
-            ...(seededResumeState?.bootstrapContext ? { bootstrapContext: seededResumeState.bootstrapContext } : {}),
-            ...(seededResumeState?.bestCandidatePath
-                ? {
-                    bestCandidatePath: seededResumeState.bestCandidatePath,
-                    bestCandidateReason: seededResumeState.bestCandidateReason,
-                }
-                : {}),
-            ...(seededResumeState?.candidatePaths ? { candidatePaths: seededResumeState.candidatePaths } : {}),
-            ...(seededResumeState?.recentReadPaths ? { recentReadPaths: seededResumeState.recentReadPaths } : {}),
-            ...(seededResumeState?.recentActionKeys
-                ? { recentActionKeys: seededResumeState.recentActionKeys }
-                : {}),
-        };
-        this.updateWorkflowPhase(state, this.createEmptyToolTrace());
-        // Track the record ID if we're syncing
-        let recordId;
-        // Extract local tool names for prompt injection
-        const localToolNames = options.localTools ? Object.keys(options.localTools) : undefined;
-        if (!options.previousMessages) {
-            state.bootstrapContext = await this.generateBootstrapDiscoveryContext(options.message, options.localTools);
-            const bootstrapCandidate = this.extractBestCandidateFromBootstrapContext(state.bootstrapContext);
-            if (bootstrapCandidate) {
-                state.bestCandidatePath = bootstrapCandidate.path;
-                state.bestCandidateReason = bootstrapCandidate.reason;
-                state.candidatePaths = [bootstrapCandidate.path];
-            }
-        }
-        // Session loop
-        for (let session = 0; session < maxSessions; session++) {
-            const sessionTrace = this.createEmptyToolTrace();
-            const sessionLocalTools = this.wrapLocalToolsForTrace(options.localTools, sessionTrace, state);
-            const sessionCallbacks = this.createTraceCallbacks(options.streamCallbacks, sessionTrace);
-            // Build continuation context for resumed runs (first session only)
-            const continuationContext = session === 0 && options.previousMessages
-                ? {
-                    previousMessages: options.previousMessages,
-                    newUserMessage: options.continuationMessage,
-                    compact: options.compact,
-                }
-                : undefined;
-            // Store original message on first invocation (not a continuation)
-            if (session === 0 && !options.previousMessages) {
-                state.originalMessage = options.message;
-            }
-            // Build messages for this session
-            const messages = this.buildSessionMessages(options.message, state, session, maxSessions, localToolNames, continuationContext);
-            // Execute one session
-            let sessionResult;
-            const sessionData = {
-                messages,
-                debugMode: options.debugMode,
-                model: options.model,
-            };
-            if (useStream && options.localTools) {
-                // Local tools require the pause/resume streaming loop
-                const completeEvent = await this.executeWithLocalTools(id, sessionData, sessionLocalTools || options.localTools, sessionCallbacks, {
-                    onLocalToolResult: this.createLocalToolLoopGuard(state, sessionTrace),
-                });
-                if (!completeEvent) {
-                    throw new Error('Agent stream ended without a complete event');
-                }
-                sessionResult = {
-                    success: completeEvent.success,
-                    result: completeEvent.finalOutput || '',
-                    iterations: completeEvent.iterations,
-                    totalCost: completeEvent.totalCost || 0,
-                    stopReason: completeEvent.stopReason,
-                    error: completeEvent.error,
-                };
-            }
-            else if (useStream && options.streamCallbacks) {
-                const completeEvent = await this.executeWithCallbacks(id, sessionData, sessionCallbacks || options.streamCallbacks);
-                if (!completeEvent) {
-                    throw new Error('Agent stream ended without a complete event');
-                }
-                sessionResult = {
-                    success: completeEvent.success,
-                    result: completeEvent.finalOutput || '',
-                    iterations: completeEvent.iterations,
-                    totalCost: completeEvent.totalCost || 0,
-                    stopReason: completeEvent.stopReason,
-                    error: completeEvent.error,
-                };
-            }
-            else {
-                sessionResult = await this.execute(id, sessionData);
-            }
-            const toolTraceSummary = this.buildToolTraceSummary(sessionTrace);
-            const effectiveSessionOutput = this.buildEffectiveSessionOutput(sessionResult.result, toolTraceSummary);
-            // Update state
-            const sessionCost = sessionResult.totalCost;
-            state.sessionCount = session + 1;
-            state.totalCost += sessionCost;
-            state.lastOutput = effectiveSessionOutput;
-            state.lastError =
-                sessionResult.stopReason === 'error'
-                    ? sessionResult.error || 'Agent session ended with an error.'
-                    : undefined;
-            state.lastStopReason = sessionResult.stopReason;
-            state.updatedAt = new Date().toISOString();
-            state.sessions.push({
-                index: session + 1,
-                cost: sessionCost,
-                iterations: sessionResult.iterations,
-                stopReason: sessionResult.stopReason,
-                outputPreview: effectiveSessionOutput.slice(0, 300),
-                toolTraceSummary: toolTraceSummary || undefined,
-                discoveryPerformed: sessionTrace.discoveryPerformed,
-                attemptedWrite: sessionTrace.attemptedWrite,
-                wroteFiles: sessionTrace.wroteFiles,
-                hadTextOutput: Boolean(sessionResult.result.trim()),
-                verificationAttempted: sessionTrace.verificationAttempted,
-                verificationPassed: sessionTrace.verificationPassed,
-                bestCandidatePath: sessionTrace.bestCandidatePath || undefined,
-                actionKeys: sessionTrace.actionKeys.slice(-5),
-                completedAt: new Date().toISOString(),
-            });
-            if (sessionTrace.bestCandidatePath) {
-                state.bestCandidatePath = sessionTrace.bestCandidatePath;
-                state.bestCandidateReason = sessionTrace.bestCandidateReason;
-            }
-            if (sessionTrace.candidatePaths.length > 0) {
-                state.candidatePaths = Array.from(new Set([...(state.candidatePaths || []), ...sessionTrace.candidatePaths])).slice(-20);
-            }
-            if (sessionTrace.readPaths.length > 0) {
-                state.recentReadPaths = Array.from(new Set([...(state.recentReadPaths || []), ...sessionTrace.readPaths])).slice(-20);
-            }
-            if (sessionTrace.actionKeys.length > 0) {
-                state.recentActionKeys = [...(state.recentActionKeys || []), ...sessionTrace.actionKeys].slice(-20);
-            }
-            if (sessionTrace.planWritten) {
-                state.planWritten = true;
-            }
-            if (sessionTrace.executionFileWritten) {
-                state.lastVerificationPassed = false;
-            }
-            if (sessionTrace.bestCandidateWritten) {
-                state.bestCandidateNeedsVerification = true;
-                state.bestCandidateVerified = false;
-            }
-            if (sessionTrace.bestCandidateVerified) {
-                state.bestCandidateNeedsVerification = false;
-                state.bestCandidateVerified = true;
-            }
-            if (sessionTrace.verificationAttempted) {
-                state.lastVerificationPassed = sessionTrace.verificationPassed;
-            }
-            // Track cost by model
-            const modelKey = options.model || 'default';
-            if (!state.costByModel)
-                state.costByModel = {};
-            state.costByModel[modelKey] = (state.costByModel[modelKey] || 0) + sessionCost;
-            this.updateWorkflowPhase(state, sessionTrace);
-            const phaseTransitionSummary = state.phaseTransitionSummary;
-            if (phaseTransitionSummary) {
-                state.lastOutput = [phaseTransitionSummary, '', state.lastOutput].join('\n').trim();
-                const latestSession = state.sessions[state.sessions.length - 1];
-                if (latestSession) {
-                    latestSession.outputPreview = [phaseTransitionSummary, '', latestSession.outputPreview]
-                        .join('\n')
-                        .slice(0, 300);
-                    latestSession.toolTraceSummary = [phaseTransitionSummary, '', latestSession.toolTraceSummary || '']
-                        .join('\n')
-                        .trim()
-                        .slice(0, 1200);
-                }
-            }
-            // Accumulate messages for future continuation.
-            // When buildSessionMessages returns the full history + a new continuation
-            // message, only the NEW messages at the end are appended — otherwise the
-            // history would be re-pushed on every session and grow exponentially.
-            if (!state.messages)
-                state.messages = [];
-            if (state.messages.length > 0 && messages.length > state.messages.length) {
-                // Continuation session: history was replayed, only append the new tail
-                const newMessages = messages.slice(state.messages.length);
-                state.messages.push(...newMessages);
-            }
-            else {
-                // First session (or no prior history): all messages are new
-                state.messages.push(...messages);
-            }
-            // Always store an assistant message so continuation sessions have full
-            // conversation history. When the agent only made tool calls and produced
-            // no text, fall back to a synthetic summary so the history stays coherent.
-            const assistantContent = effectiveSessionOutput ||
-                `[Session ${session + 1} completed (${sessionResult.stopReason}). No text output captured.]`;
-            state.messages.push({ role: 'assistant', content: assistantContent });
-            // Keep session log trimmed to last 50 entries
-            if (state.sessions.length > 50) {
-                state.sessions = state.sessions.slice(-50);
-            }
-            // Check terminal conditions
-            if (sessionResult.stopReason === 'complete') {
-                state.status = 'complete';
-            }
-            else if (sessionResult.stopReason === 'error') {
-                state.status = 'error';
-            }
-            else if (sessionResult.stopReason === 'max_cost') {
-                state.status = 'budget_exceeded';
-            }
-            else if (this.canAcceptTaskCompletion(sessionResult.result, state, sessionTrace)) {
-                // Client-side stop-phrase detection for non-loop agents returning 'end_turn'
-                state.status = 'complete';
-            }
-            else if (maxCost && state.totalCost >= maxCost) {
-                state.status = 'budget_exceeded';
-            }
-            else if (session + 1 >= maxSessions) {
-                state.status = 'max_sessions';
-            }
-            // Sync to record if enabled
-            if (options.trackProgress) {
-                recordId = await this.syncProgressRecord(state, recordId);
-            }
-            // Notify caller
-            if (options.onSession) {
-                const shouldStop = await options.onSession(state);
-                if (shouldStop === false) {
-                    state.status = 'paused';
-                }
-            }
-            // Stop if terminal
-            if (state.status !== 'running') {
-                break;
-            }
-        }
-        return {
-            status: state.status,
-            sessionCount: state.sessionCount,
-            totalCost: state.totalCost,
-            lastOutput: state.lastOutput,
-            sessions: state.sessions,
-            recordId,
-        };
-    }
-    /**
-     * Client-side fallback for detecting task completion in agent output.
-     * Mirrors the API's detectAutoComplete() for non-loop agents that return 'end_turn'.
-     */
-    detectTaskCompletion(output) {
-        const upper = output.toUpperCase();
-        return AgentsEndpoint.STOP_PHRASES.some((phrase) => upper.includes(phrase.toUpperCase()));
-    }
-    /**
-     * Generate a compact summary of prior work for continuation context.
-     * Used when compact mode is enabled to keep token usage low.
-     */
-    generateCompactSummary(state) {
-        const sessionSummaries = (state.sessions ?? [])
-            .map((s) => `- Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) -- ${s.outputPreview.slice(0, 100)}`)
-            .join('\n');
-        return [
-            `Task: ${state.taskName}`,
-            `Status: ${state.status}`,
-            `Workflow phase: ${state.workflowPhase || 'research'}`,
-            `Sessions completed: ${state.sessionCount}`,
-            `Total cost: $${state.totalCost.toFixed(4)}`,
-            ...(state.planPath ? [`Plan path: ${state.planPath}`] : []),
-            ...(state.planWritten ? ['Plan written: yes'] : []),
-            ...(state.bestCandidatePath
-                ? [
-                    `Best candidate: ${state.bestCandidatePath}`,
-                    ...(state.bestCandidateReason ? [`Candidate reason: ${state.bestCandidateReason}`] : []),
-                ]
-                : []),
-            ...(state.bootstrapContext ? ['', state.bootstrapContext] : []),
-            '',
-            'Session history:',
-            sessionSummaries,
-            '',
-            'Last output (truncated):',
-            (state.lastOutput || '').slice(0, 1500),
-        ].join('\n');
-    }
-    /**
-     * Build messages for a session, injecting progress context for continuation sessions.
-     * Optionally accepts continuation context for marathon resume scenarios.
-     */
-    buildSessionMessages(originalMessage, state, sessionIndex, maxSessions, localToolNames, continuationContext) {
-        // Build local tools guidance block when tools are available
-        const phase = state.workflowPhase || 'research';
-        const toolsBlock = localToolNames?.length
-            ? [
-                '',
-                '--- Local Tools ---',
-                `You have access to local filesystem tools (${localToolNames.join(', ')}) that execute directly on the user's machine.`,
-                'Use these tools to inspect the existing repository and make real file edits — not just code in your response.',
-                ...(phase === 'research'
-                    ? [
-                        'For repository modification tasks, before any write_file call you must perform at least one discovery action (search_repo, glob_files, or tree_directory).',
-                        'If discovery finds a plausible existing file, you must read at least one candidate file before writing.',
-                        'Before creating a new file, search the repo for existing relevant files, routes, links, components, or pages.',
-                        'Prefer editing an existing file when one already implements or links to the feature you were asked to change.',
-                        'Use search_repo, glob_files, and tree_directory to discover the right files before you call write_file.',
-                        'Only create a new file when no suitable existing file exists, and make that decision intentionally.',
-                    ]
-                    : phase === 'planning'
-                        ? [
-                            `Research is already complete. Focus on writing or updating the plan at: ${state.planPath || this.getDefaultPlanPath(state.taskName)}.`,
-                            'Do not restart broad repo discovery unless the saved best candidate is clearly invalid.',
-                            'You may read the current target file or supporting source files if you need evidence for the plan.',
-                            'Ground the plan in the existing implementation. Identify which current behaviors and linked files must be preserved.',
-                            'List the exact verification commands you expect to run after editing, such as lint, typecheck, tests, or build.',
-                        ]
-                        : [
-                            ...(state.bestCandidatePath
-                                ? [
-                                    `Execution-phase guard: broad discovery tools (search_repo, glob_files, tree_directory, list_directory) are locked while executing against "${state.bestCandidatePath}".`,
-                                ]
-                                : [
-                                    'Execution-phase guard: broad discovery tools are locked unless a read of the current target fails.',
-                                ]),
-                            'Reading the markdown plan for status does not change the product target. Do not treat the plan file as the file to implement.',
-                            'Do not write the plan file first in execution. Make a real repo-file edit before you update the plan with progress.',
-                            'Do not create scratch or test files to probe the repo or tool behavior.',
-                            'write_file automatically checkpoints original repo files before overwriting them. If an edit regresses behavior, use restore_file_checkpoint on that file.',
-                            'Read the target file and edit it with write_file. Update the plan file with progress after completing real edits.',
-                            'Before large edits, read any already discovered supporting source/style files that power the target so you preserve existing behavior.',
-                            'Prefer minimal diffs over rewrites. If you cannot verify related behavior, stop and record what is still unverified instead of rewriting blindly.',
-                            'Use run_check for real verification before TASK_COMPLETE. Good examples: "pnpm lint", "pnpm exec tsc --noEmit", "pnpm test", or a focused vitest/pytest command.',
-                            'Broad discovery is only allowed if a read of the current target file fails.',
-                        ]),
-                'Always use write_file to save your output so the user can run it immediately.',
-            ].join('\n')
-            : '';
-        const bootstrapBlock = state.bootstrapContext
-            ? ['', '--- Initial Repository Discovery ---', state.bootstrapContext].join('\n')
-            : '';
-        const phaseBlock = ['', this.buildPhaseInstructions(state)].join('\n');
-        const candidateBlock = state.bestCandidatePath
-            ? [
-                '',
-                '--- Best Candidate ---',
-                `Current best candidate file: ${state.bestCandidatePath}`,
-                ...(state.bestCandidateReason ? [`Why: ${state.bestCandidateReason}`] : []),
-            ].join('\n')
-            : '';
-        const multiSessionInstruction = `This is a multi-session task (session ${sessionIndex + 1}/${maxSessions}). When you have fully completed the task, end your response with TASK_COMPLETE on its own line.`;
-        // Continuation resume: first session of a resumed run with prior context
-        if (continuationContext && sessionIndex === 0) {
-            const defaultContinueMessage = 'Continue the task. Review your prior work above and proceed with any remaining work. If everything is already complete, respond with TASK_COMPLETE.';
-            const userMessage = continuationContext.newUserMessage || defaultContinueMessage;
-            if (continuationContext.compact) {
-                // Compact mode: summarize prior work instead of full history
-                const summary = this.generateCompactSummary(state);
-                const messages = [
-                    {
-                        role: 'system',
-                        content: `You are continuing a previously completed task. Here is a summary of prior work:\n\n${summary}\n\nDo NOT redo any of the above work.`,
-                    },
-                    {
-                        role: 'user',
-                        content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, '', multiSessionInstruction].join('\n'),
-                    },
-                ];
-                return messages;
-            }
-            // Full history mode: replay all previous messages with do-not-redo instruction
-            const messages = [
-                ...continuationContext.previousMessages,
-                {
-                    role: 'system',
-                    content: 'IMPORTANT: You are continuing a previously completed task. The conversation above shows your prior work. Do NOT redo any of it. Build on what was already accomplished. If there is nothing new to do, respond with TASK_COMPLETE.',
-                },
-                {
-                    role: 'user',
-                    content: [userMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, '', multiSessionInstruction].join('\n'),
-                },
-            ];
-            return messages;
-        }
-        // First session (non-continuation): user message + completion signal instruction
-        if (sessionIndex === 0) {
-            const content = [originalMessage, phaseBlock, toolsBlock, bootstrapBlock, candidateBlock, '', multiSessionInstruction].join('\n');
-            return [{ role: 'user', content }];
-        }
-        // Continuation sessions within a run: inject progress context
-        const recentSessions = state.sessions.slice(-5);
-        const progressSummary = recentSessions
-            .map((s) => `  Session ${s.index}: ${s.stopReason} ($${s.cost.toFixed(4)}) — ${s.outputPreview.slice(0, 100)}`)
-            .join('\n');
-        // When we have accumulated message history, replay the full conversation
-        // so the model has complete context and doesn't start fresh each session.
-        if (state.messages && state.messages.length > 0) {
-            const recoveryMessage = this.buildStuckTurnRecoveryMessage(state);
-            const continuationContent = [
-                'Continue the task.',
-                phaseBlock,
-                toolsBlock,
-                bootstrapBlock,
-                candidateBlock,
-                '',
-                `--- Progress (session ${sessionIndex + 1}/${maxSessions}, $${state.totalCost.toFixed(4)} spent) ---`,
-                `Previous sessions:`,
-                progressSummary,
-                '',
-                ...(recoveryMessage ? [recoveryMessage, ''] : []),
-                'Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE.',
-            ].join('\n');
-            // Cap history to prevent context overflow on long-running marathons.
-            // Keep the most recent 40 messages; prepend a system summary for trimmed ones.
-            const MAX_HISTORY_MESSAGES = 40;
-            let historyMessages = state.messages;
-            if (historyMessages.length > MAX_HISTORY_MESSAGES) {
-                const trimmedCount = historyMessages.length - MAX_HISTORY_MESSAGES;
-                historyMessages = [
-                    {
-                        role: 'system',
-                        content: `[${trimmedCount} earlier messages trimmed to stay within context limits. Original task: ${(state.originalMessage || originalMessage).slice(0, 500)}]`,
-                    },
-                    ...historyMessages.slice(-MAX_HISTORY_MESSAGES),
-                ];
-            }
-            return [
-                ...historyMessages,
-                { role: 'user', content: continuationContent },
-            ];
-        }
-        // Fallback when no message history is available: single-message summary
-        const recoveryMessage = this.buildStuckTurnRecoveryMessage(state);
-        const content = [
-            originalMessage,
-            phaseBlock,
-            toolsBlock,
-            bootstrapBlock,
-            candidateBlock,
-            '',
-            `--- Progress (session ${sessionIndex + 1}/${maxSessions}, $${state.totalCost.toFixed(4)} spent) ---`,
-            `Previous sessions:`,
-            progressSummary,
-            '',
-            ...(recoveryMessage ? [recoveryMessage, ''] : []),
-            `Last output (do NOT repeat this — build on it):`,
-            state.lastOutput.slice(0, 1000),
-            '',
-            'Continue where you left off. Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE.',
-        ].join('\n');
-        return [{ role: 'user', content }];
-    }
-    /**
-     * Upsert a record to sync long-task progress to the dashboard.
-     * Creates the record on first call, updates it on subsequent calls.
-     */
-    async syncProgressRecord(state, existingRecordId) {
-        const metadata = {
-            agentId: state.agentId,
-            agentName: state.agentName,
-            status: state.status,
-            sessionCount: state.sessionCount,
-            totalCost: state.totalCost,
-            lastStopReason: state.lastStopReason,
-            lastOutputPreview: state.lastOutput.slice(0, 500),
-            sessions: state.sessions.slice(-10), // Keep last 10 in the record
-            startedAt: state.startedAt,
-            updatedAt: state.updatedAt,
-        };
-        try {
-            if (existingRecordId) {
-                // Update existing record
-                const record = await this.client.put(`/records/${existingRecordId}`, {
-                    metadata,
-                });
-                return record.id;
-            }
-            else {
-                // Try to find existing record by type + name first
-                const existing = await this.client.get('/records', {
-                    type: 'agent-task',
-                    name: state.taskName,
-                    limit: 1,
-                });
-                if (existing.data.length > 0) {
-                    const record = await this.client.put(`/records/${existing.data[0].id}`, {
-                        metadata,
-                    });
-                    return record.id;
-                }
-                // Create new record
-                const record = await this.client.post('/records', {
-                    type: 'agent-task',
-                    name: state.taskName,
-                    metadata,
-                });
-                return record.id;
-            }
-        }
-        catch {
-            // Record sync is best-effort — don't fail the task
-            return existingRecordId || '';
-        }
-    }
-}
-exports.AgentsEndpoint = AgentsEndpoint;
-/** Stop phrases that indicate the agent considers its task complete. */
-AgentsEndpoint.STOP_PHRASES = [
-    'DONE:',
-    'TASK_COMPLETE',
-    'FINISHED',
-    '[COMPLETE]',
-    'STATUS: RESOLVED',
-    'STATUS: COMPLETE',
-];
-//# sourceMappingURL=endpoints.js.map