omnara 0.6.0 → 0.6.1

package/dist/orchestrator/orchestrator-prompt.md

@@ -1,222 +0,0 @@
-# Role: Task Orchestrator
-
-You are Omnara, an orchestrator agent. Your job is to coordinate work by delegating to worker agents while staying responsive to user interaction.
-
-## The Mental Model
-
-**You stay zoomed out. Workers go zoomed in.**
-
-You are a coordinator who maintains the big picture. Workers are specialists who dive deep into specific domains. When a worker investigates authentication, they accumulate valuable context about the auth system. That context is an asset - reuse it.
-
-**Context is valuable. Accuracy over speed.**
-
-A worker who already understands a domain will do better work than a fresh worker starting from zero. Always prefer routing work to workers with relevant context over launching new workers.
-
----
-
-## Tool Restrictions
-
-**FORBIDDEN tools (delegate these to workers):**
-- Write, Edit, Bash, NotebookEdit
-
-**Allowed tools (read-only, use sparingly):**
-- Read, Grep, Glob - For quick lookups (1-2 calls max)
-- WebFetch, WebSearch - For external information
-- TodoWrite - For tracking multi-step tasks
-
-**Why?** Using forbidden tools blocks your context. Workers execute operations without blocking you. Your job is to coordinate, not implement.
-
----
-
-## The Routing Decision
-
-When a user request comes in, follow this decision tree:
-
-```
-New request arrives
-    |
-    v
-Is there a completed worker whose domain matches this request?
-    |
-    YES --> Route to that worker (message_worker)
-    NO  --> Is there a running worker whose domain matches?
-                |
-                YES --> Queue message to that worker (message_worker, interrupt=false)
-                NO  --> Launch a new worker
-```
-
-**How to identify matching domains:** Check the worker-status in your system prompt and [Automated Worker Summary] messages. They show task names, status, worktree, and completion summaries.
-
-### When to Route to Existing Workers
-
-**Workers evolve over time.** A worker's task name reflects what they started with, but they accumulate context as they receive follow-up messages. They may handle related work that wasn't part of their original task but shares context. When deciding whether to route to an existing worker, don't just match on task name - consider whether the worker has touched relevant files, worked in the same domain, or has context that would be useful even if the new request isn't exactly what they originally did.
-
-Route to an existing worker when:
-- The request involves files/code that worker has touched
-- The request is in the same feature area
-- The request builds on or modifies previous work
-- The user is asking about work a worker did
-- Understanding prior decisions would be valuable
-- **A bug or question comes up related to work a worker previously did** - Message that worker to investigate/fix it instead of investigating yourself or asking the user for direction. The worker has the context and will be more effective.
-
-### When to Launch New Workers
-
-Launch a new worker only when:
-- No existing worker has relevant context
-- The request is in a completely unrelated domain
-- The user explicitly asks for a separate task
-- Work would conflict with an existing worker's activity
-
-### Routing Examples
-
-```
-Worker "auth-impl" previously: Implemented login/logout
-
-User: "Add password reset"
---> Message "auth-impl" (same domain, they know the auth system)
-
-User: "Add dark mode to settings"
---> Launch new worker (unrelated domain)
-
-User: "Why did you use JWT instead of sessions?"
---> Message "auth-impl" (they made that decision)
-```
-
----
-
-## Using message_worker
-
-**interrupt=false (default):** Queue message for after current work
-- Use for: Follow-up tasks, additional requirements, questions
-
-**interrupt=true:** Stop current work immediately
-- Use only when: User explicitly says stop, or new info contradicts current direction
-
-**Message content should include:**
-- What the user is asking for
-- How it relates to the worker's previous work (if not obvious)
-- Any new context from the user
-
-**After messaging:** Don't poll with get_workers. You'll be automatically notified when the worker completes.
-
----
-
-## Launching Workers
-
-When you do need to launch new workers:
-
-**Provide clear instructions:**
-- What to do
-- What information to return
-- Any relevant context you gathered
-
-**Use worktree_name for isolation:**
-- `worktree_name="feature-x"` creates an isolated git branch
-- Multiple workers with same worktree_name share that branch
-- Different worktree_names = fully isolated work
-- Omit for trivial changes (typos, docs)
-
-**Example delegation:**
-```
-User: "Add rate limiting to the API"
-
-launch_worker with prompt: "Add rate limiting middleware to the API.
-Apply globally with 100 requests per 15 minutes.
-Document the configuration in comments."
-worktree_name: "add-rate-limiting"
-```
-
----
-
-## Multiple Workers
-
-**Parallel workers are appropriate when:**
-- Tasks are in completely different domains
-- Tasks don't depend on each other's results
-- Example: "Fix auth bug AND add logging feature" - 2 workers, different worktrees
-
-**Sequential work should reuse the same worker:**
-- "Research auth libraries, then implement" - One worker does both
-- "Implement feature, then add tests" - Same worker continues
-
-**Avoid:** Launching parallel workers for tightly related work. The workers won't share context and may make inconsistent decisions.
-
----
-
-## Worktree Patterns
-
-**Same worktree, same worker (preferred for sequential work):**
-```
-launch_worker(worktree_name="feature-x", ...)
-[worker completes]
-message_worker(task="feature-x", message="Now do the next step...")
-```
-Context preserved. Worker knows the domain.
-
-**Different worktrees (for unrelated parallel work):**
-```
-launch_worker(worktree_name="feature-x", ...)
-launch_worker(worktree_name="feature-y", ...)
-```
-Fully isolated. Different features/branches.
-
-**Same worktree, different workers (rare - only when you want fresh perspective):**
-```
-launch_worker(worktree_name="feature-x", ...)
-[worker completes]
-launch_worker(worktree_name="feature-x", ...)  # New worker, context discarded
-```
-Use sparingly. Loses accumulated knowledge.
-
----
-
-## TodoWrite
-
-Use for multi-step tasks (2+ sequential steps) to give users visibility.
-
-**Todo states:** pending, in_progress, completed
-**Keep exactly ONE todo in_progress at a time.**
-
-```
-User: "Add OAuth, then test it"
-
-TodoWrite:
-1. "Implement OAuth" - in_progress
-2. "Test OAuth flow" - pending
-
-[Worker completes step 1]
-Update: step 1 completed, step 2 in_progress
-```
-
-Don't use TodoWrite for single tasks or simple lookups.
-
----
-
-## Responding to Worker Completions
-
-When a worker completes, you receive an [Automated Worker Summary] message containing what the worker accomplished.
-
-**Your response should:**
-1. Report ONLY the new completion (not previously reported ones)
-2. Keep it brief: "The auth worker completed. Login/logout endpoints are implemented."
-3. Note next steps if applicable
-
-**Don't:** Re-summarize all workers. Re-explain previous completions. Provide comprehensive recaps unless asked.
-
----
-
-## Remember
-
-**Your role:** Coordinator, not implementer. Stay zoomed out.
-
-**Tool restrictions:** Never use Write, Edit, Bash, NotebookEdit directly. Always delegate.
-
-**Routing priority:** Existing workers with context > New workers. Context is valuable.
-
-**Accuracy over speed:** One worker with good context beats two workers duplicating effort.
-
-**Stay responsive:** Delegate to keep your context unblocked for user interaction.
-
-**Worker status:** Check worker-status in your system prompt and [Automated Worker Summary] messages. Don't poll with get_workers.
-
-**When in doubt:** Route to an existing worker if one has relevant context. Otherwise, delegate to a new worker.

package/dist/orchestrator/orchestrator-types.d.ts

@@ -1,168 +0,0 @@
-/**
- * Internal orchestrator message types for communication between components
- * These are NOT wire protocol types - they're internal to the orchestrator
- *
- * For wire protocol types (sent over WebSocket), use:
- * - ControlMessage from @omnara/shared-js/schemas
- * - MessageEnvelope from @omnara/shared-js/schemas
- */
-import { z } from 'zod';
-export declare const inboundMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    type: z.ZodLiteral<"chat">;
-    sessionId: z.ZodOptional<z.ZodString>;
-    text: z.ZodString;
-    senderId: z.ZodOptional<z.ZodString>;
-    senderKind: z.ZodOptional<z.ZodEnum<["user", "agent_session"]>>;
-}, "strip", z.ZodTypeAny, {
-    text: string;
-    type: "chat";
-    sessionId?: string | undefined;
-    senderId?: string | undefined;
-    senderKind?: "user" | "agent_session" | undefined;
-}, {
-    text: string;
-    type: "chat";
-    sessionId?: string | undefined;
-    senderId?: string | undefined;
-    senderKind?: "user" | "agent_session" | undefined;
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"session_init">;
-    sessionId: z.ZodString;
-    parentSessionId: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    type: "session_init";
-    sessionId: string;
-    parentSessionId?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    type: "session_init";
-    sessionId: string;
-    parentSessionId?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"join">;
-    sessionId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "join";
-    sessionId: string;
-}, {
-    type: "join";
-    sessionId: string;
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"leave">;
-    sessionId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "leave";
-    sessionId: string;
-}, {
-    type: "leave";
-    sessionId: string;
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"ping">;
-}, "strip", z.ZodTypeAny, {
-    type: "ping";
-}, {
-    type: "ping";
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"cancel_worker">;
-    workerId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "cancel_worker";
-    workerId: string;
-}, {
-    type: "cancel_worker";
-    workerId: string;
-}>]>;
-export type InboundMessage = z.infer<typeof inboundMessageSchema>;
-export type OutboundMessage = {
-    type: 'session_created';
-    sessionId: string;
-    messageId?: string;
-} | {
-    type: 'session_joined';
-    sessionId: string;
-    messageId?: string;
-} | {
-    type: 'session_init';
-    sessionId: string;
-    parentSessionId?: string | null;
-    metadata?: Record<string, unknown>;
-    messageId?: string;
-} | {
-    type: 'session_init_ack';
-    sessionId: string;
-    parentSessionId?: string | null;
-    messageId?: string;
-} | {
-    type: 'user_text';
-    sessionId: string;
-    text: string;
-    origin?: 'user' | 'worker';
-    workerId?: string;
-    workerTask?: string;
-    metadata?: Record<string, unknown>;
-    messageId?: string;
-} | {
-    type: 'assistant_text';
-    sessionId: string;
-    text: string;
-    workerId?: string;
-    workerTask?: string;
-    messageId?: string;
-} | {
-    type: 'agent_complete';
-    sessionId: string;
-    success: boolean;
-    durationMs?: number;
-    costUsd?: number;
-    message?: string;
-    worktree_path?: string;
-    branch_name?: string;
-    metadata?: Record<string, unknown>;
-    messageId?: string;
-} | {
-    type: 'tool_call';
-    sessionId: string;
-    toolName: string;
-    toolUseId: string;
-    input: unknown;
-    workerId?: string;
-    workerTask?: string;
-    messageId?: string;
-} | {
-    type: 'tool_result';
-    sessionId: string;
-    toolUseId: string;
-    content: unknown;
-    isError?: boolean;
-    workerId?: string;
-    workerTask?: string;
-    messageId?: string;
-} | {
-    type: 'agent_progress';
-    sessionId?: string;
-    status: string;
-    detail?: string;
-    metadata?: Record<string, unknown>;
-    messageId?: string;
-} | {
-    type: 'system';
-    sessionId: string;
-    subtype: string;
-    metadata?: Record<string, unknown>;
-    messageId?: string;
-} | {
-    type: 'error';
-    sessionId?: string;
-    message: string;
-    messageId?: string;
-} | {
-    type: 'pong';
-    messageId?: string;
-};
-export interface SessionSubscriber {
-    id: string;
-    send: (message: OutboundMessage) => void;
-    canSend?: () => boolean;
-}

package/dist/orchestrator/session.d.ts

@@ -1,83 +0,0 @@
-import { type Options, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { AgentClient } from './ai-client.js';
-import type { MessageEnvelope, MessageEnvelopeSchema } from '@omnara/shared-js/schemas';
-interface UserTextSender extends MessageEnvelopeSchema.SenderRef {
-    kind: 'user';
-}
-interface UserTextPayload extends MessageEnvelopeSchema.MessagePayload {
-    content: MessageEnvelopeSchema.TextContent;
-}
-export interface UserTextEnvelope extends MessageEnvelope {
-    sender: UserTextSender;
-    payload: UserTextPayload;
-}
-interface CompletePayload extends MessageEnvelopeSchema.MessagePayload {
-    content: MessageEnvelopeSchema.AgentCompleteContent;
-}
-export interface CompleteMessageEnvelope extends MessageEnvelope {
-    payload: CompletePayload;
-}
-export interface SessionInitNotification {
-    type: 'session_init';
-    sessionId: string;
-    parentSessionId: string | null;
-    metadata?: Record<string, unknown>;
-}
-interface SessionOptions {
-    parentSessionId?: string | null;
-    metadata?: Record<string, unknown>;
-    sessionType?: string;
-    summarize?: boolean;
-}
-export declare class Session implements AsyncIterable<SDKUserMessage> {
-    id: string;
-    private ai;
-    sdkSessionIdentifier?: string;
-    private envelopeSubscribers;
-    private sessionInitSubscribers;
-    private queue;
-    private generating;
-    private waitingForMessage;
-    private announcementPromise;
-    private announced;
-    private shouldSummarize;
-    private conversationHistory;
-    private retryDelayMs;
-    private retryCount;
-    private readonly sessionInitControl;
-    constructor(id: string, ai: AgentClient, options?: SessionOptions);
-    enqueue(message: UserTextEnvelope): void;
-    [Symbol.asyncIterator](): AsyncIterator<SDKUserMessage>;
-    private generate;
-    private startGenerate;
-    private captureSdkSessionId;
-    private collectAssistantSummaryBlocks;
-    private buildCompletionEnvelope;
-    private buildErrorCompletionEnvelope;
-    private resetRetryState;
-    private summarize;
-    private emitProgress;
-    onEnvelope(cb: (msg: MessageEnvelope) => void | Promise<void>): void;
-    onSessionInit(cb: (control: SessionInitNotification) => void | Promise<void>): void;
-    setOptions(options: Partial<Options>): void;
-    getOptions(): Options;
-    cancel(): Promise<void>;
-    /**
-     * Generate a commit message based on conversation context and the provided diff.
-     * Uses the conversation history to understand the intent and context of changes,
-     * combined with the diff to produce a meaningful commit message.
-     */
-    generateCommitMessage(diff: string): Promise<string>;
-    /**
-     * Build a condensed representation of the conversation history for commit message generation.
-     * Limits the context to avoid overwhelming the model while capturing key intent.
-     */
-    private buildConversationContext;
-    /**
-     * Build the prompt for commit message generation.
-     */
-    private buildCommitMessagePrompt;
-    private dispatchEnvelope;
-    private emitSessionInit;
-}
-export {};

package/dist/orchestrator/tools/worker-tools.d.ts

@@ -1,10 +0,0 @@
-import type { WorkerManager } from '../worker-manager.js';
-export declare const WORKER_LAUNCH_TOOL = "mcp__worker__launch_worker";
-export declare const WORKER_MESSAGE_TOOL = "mcp__worker__message_worker";
-interface WorkerMcpContext {
-    resolveSessionIdBySdk: (sdkSessionId?: string) => string | undefined;
-    resolveSessionIdByToolUse: (toolUseId: string) => string | undefined;
-    getMainCodingSessionId: () => string | null;
-}
-export declare function createWorkerMcpServer(workerManager: WorkerManager, context: WorkerMcpContext): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
-export {};

package/dist/orchestrator/utils/completions-manager.d.ts

@@ -1,8 +0,0 @@
-import type { ControlMessageSchema } from '@omnara/shared-js/schemas';
-export declare class CompletionsManager {
-    private slashCommandsCache?;
-    private filesCache;
-    fetchSlashCommands(): Promise<string[]>;
-    fetchFiles(searchPattern?: string): Promise<string[]>;
-    getCompletion(query: string, limit?: number): Promise<ControlMessageSchema.CompletionItem[]>;
-}

package/dist/orchestrator/utils/envelope-utils.d.ts

@@ -1,13 +0,0 @@
-import type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { MessageEnvelope, MessageEnvelopeSchema } from '@omnara/shared-js/schemas';
-type TextBlock = {
-    type: 'text';
-    text: string;
-};
-export declare function createEnvelope(sessionId: string, content: MessageEnvelopeSchema.Content, senderId?: string, metadata?: Record<string, unknown>, payloadMetadata?: Record<string, unknown>): MessageEnvelope;
-export declare function toMessageEnvelopes(message: SDKMessage, sessionId: string): MessageEnvelope[];
-export declare function normalizeToolArguments(input: unknown): Record<string, unknown>;
-export declare function normalizeToolResult(output: unknown): Record<string, unknown>;
-export declare function isTextBlock(block: unknown): block is TextBlock;
-export declare function extractTextDelta(message: SDKMessage): string | null;
-export {};

package/dist/orchestrator/utils/index.d.ts

@@ -1,2 +0,0 @@
-export { WorktreeManager } from './worktree-manager.js';
-export type { SessionLogger } from './session-logger.js';

package/dist/orchestrator/utils/session-logger.d.ts

@@ -1,7 +0,0 @@
-import type { OutboundMessage } from '../orchestrator-types.js';
-export type SessionLogger = {
-    logInbound: (payload: unknown) => void;
-    logOutbound: (message: OutboundMessage) => void;
-    close: () => void;
-};
-export declare function createSessionLogger(sessionId: string): SessionLogger;

package/dist/orchestrator/utils/worker-events.d.ts

@@ -1,7 +0,0 @@
-import type { WorkerRecord } from '../worker-types.js';
-import type { OutboundMessage } from '../orchestrator-types.js';
-export declare function formatWorkerSummary(record: WorkerRecord, override?: string): string;
-export declare function createWorkerProgressMessage(record: WorkerRecord): OutboundMessage;
-export declare function createWorkerCompletionMessage(record: WorkerRecord, summary: string): OutboundMessage;
-export declare function buildWorkerCompletionPrompt(record: WorkerRecord): string;
-export declare function buildAgentCompletionMessage(resultText: string | null, summary: string, errorText: string | null): string;

package/dist/orchestrator/utils/worktree-manager.d.ts

@@ -1,51 +0,0 @@
-import { type SimpleGit } from 'simple-git';
-import type { WorkspaceConfigSchema } from '@omnara/shared-js/schemas';
-export declare class WorktreeManager {
-    private repoPath;
-    readonly git: SimpleGit;
-    private repoName;
-    private readonly worktrees;
-    private worktreeUsers;
-    private worktreeBasePath;
-    constructor(repoPath: string);
-    getWorktreeConfig(): Promise<WorkspaceConfigSchema.WorktreeSettings | undefined>;
-    /**
-     * Get the directory path for a worktree, creating it if necessary.
-     *
-     * @param worktreeName - The name of the worktree (also used as branch name)
-     * @param workerId - Identifier for the worker using this worktree
-     * @returns The path to the worktree directory
-     */
-    getWorktreeDirectory(worktreeName: string, workerId: string): Promise<string>;
-    /**
-     * Internal method that performs the actual worktree creation
-     * This should only be called by processCreationQueue
-     */
-    private createWorktree;
-    removeWorktreeUser(worktreeName: string, workerId: string, force?: boolean): Promise<void>;
-    cleanupAll(force?: boolean): Promise<void>;
-    listActiveWorktrees(): Array<{
-        worktreeName: string;
-        branchName: string;
-        worktreePath: string;
-    }>;
-    /**
-     * Parses the output of 'git worktree list --porcelain'
-     *
-     * @param output - Raw output from git worktree list
-     * @returns Array of worktree paths
-     */
-    private parseWorktreeList;
-    /**
-     * Find a valid base ref to use when creating new branches
-     * Tries in order: configured base_ref, main, master, origin/HEAD
-     * @returns The first valid ref found, or undefined if none exist
-     */
-    private findValidBaseRef;
-    /**
-     * Stage all changes in the specified worktree by running `git add -A`
-     * @param worktreePath - Path to the worktree directory
-     */
-    stageAllChanges(worktreePath: string): Promise<void>;
-    commitChanges(worktreeName?: string, message?: string): Promise<void>;
-}

package/dist/orchestrator/worker-manager.d.ts

@@ -1,81 +0,0 @@
-import type { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
-import { type AgentClient, type ModelType } from './ai-client.js';
-import { Session, type CompleteMessageEnvelope } from './session.js';
-import type { WorkerStatus } from './worker-types.js';
-import type { MessageEnvelope } from '@omnara/shared-js/schemas';
-export type { WorkerStatus, WorkerRecord, WorkerSessionMessageEvent } from './worker-types.js';
-interface LaunchWorkerOptions {
-    task: string;
-    prompt: string;
-    originSessionId: string;
-    metadata?: Record<string, unknown>;
-}
-interface WorkerManagerOptions {
-    createClient: (mcpServers?: Record<string, McpServerConfig>, cwd?: string) => AgentClient;
-    broadcastMessage: (msg: MessageEnvelope) => Promise<void> | void;
-    broadcastComplete: (complete: CompleteMessageEnvelope) => Promise<void> | void;
-    announceWorkerSession?: (info: {
-        sessionId: string;
-        parentSessionId?: string;
-        metadata?: Record<string, unknown>;
-    }) => Promise<void> | void;
-    repoPath: string;
-    /** Working directory for workers. If not set, uses repoPath. Can be updated via setWorkingDirectory(). */
-    workingDirectory?: string;
-}
-type Worker = {
-    status: WorkerStatus;
-    session: Session;
-    ai: AgentClient;
-    task: string;
-    parentSessionId: string;
-    directory: string;
-    startedAt: number;
-    lastUpdateAt: number;
-};
-export declare class WorkerManager {
-    private readonly options;
-    private workers;
-    private workerModel;
-    private workingDirectory;
-    broadcastMessage: (msg: MessageEnvelope) => Promise<void> | void;
-    broadcastComplete: (complete: CompleteMessageEnvelope) => Promise<void> | void;
-    readonly repoPath: string;
-    private readonly announceWorkerSession?;
-    constructor(options: WorkerManagerOptions);
-    /**
-     * Set the working directory for new workers.
-     * Use this to point workers at a worktree directory.
-     */
-    setWorkingDirectory(directory: string): void;
-    /**
-     * Get the current working directory used for new workers.
-     */
-    getWorkingDirectory(): string;
-    /**
-     * Set the model to use for all workers (current running and future).
-     */
-    setWorkerModel(model: ModelType): void;
-    /**
-     * Get the current model used for workers.
-     */
-    getWorkerModel(): ModelType;
-    listWorkers(): Worker[];
-    getWorker(id: string): Worker | undefined;
-    getWorkerByTask(task: string): Worker | undefined;
-    cancelWorker(id: string): Promise<boolean>;
-    launchWorker({ task, prompt, originSessionId, metadata, }: LaunchWorkerOptions): Promise<Worker>;
-    /**
-     * Route a user message to a worker by session ID.
-     * Thin wrapper around enqueueMessage.
-     */
-    userMessageWorker(sessionId: string, userId: string, message: string): Promise<boolean>;
-    /**
-     * Send a message to a worker (running or completed).
-     * Thin wrapper around enqueueMessage.
-     */
-    toolMessageWorker(task: string, message: string): Promise<boolean>;
-    shutdown(): Promise<void>;
-    private onComplete;
-    onMessage(id: string, msg: MessageEnvelope): Promise<void>;
-}

package/dist/orchestrator/worker-types.d.ts

@@ -1,23 +0,0 @@
-import type { MessageEnvelope } from '@omnara/shared-js/schemas';
-import type { Session } from './session.js';
-export type WorkerStatus = 'running' | 'completed' | 'error' | 'canceled';
-export interface WorkerRecord {
-    id: string;
-    task: string;
-    prompt: string;
-    sdkSessionId?: string | null;
-    status: WorkerStatus;
-    startedAt: number;
-    lastUpdateAt: number;
-    originSessionId?: string;
-    result?: string;
-    error?: string;
-    metadata?: Record<string, unknown>;
-    session?: Session;
-    worktreePath?: string;
-    worktreeName?: string;
-}
-export interface WorkerSessionMessageEvent {
-    record: WorkerRecord;
-    message: MessageEnvelope;
-}