omnara 0.2.4 → 0.3.0

package/dist/commands/index.d.ts

@@ -1,3 +1,4 @@
 export { runAgentOrchestrator, type OrchestratorOptions } from './agent.js';
 export { buildAuthCommand } from './auth.js';
 export { buildDaemonCommand } from './daemon.js';
+export { buildKillCommand } from './kill.js';

package/dist/commands/kill.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function buildKillCommand(): Command;

package/dist/daemon/daemon-launcher.d.ts

@@ -28,3 +28,10 @@ export declare function startDaemon(options?: StartDaemonOptions): Promise<boole
 export declare function stopDaemon(options?: StopDaemonOptions): Promise<boolean>;
 export declare function showDaemonStatus(options?: StatusOptions): Promise<void>;
 export declare function killAllDaemonProcesses(options?: KillAllOptions): Promise<void>;
+export declare function killDaemonByState(options?: {
+    logger?: Logger;
+    dev?: boolean;
+}): Promise<void>;
+export declare function killSessionsByRegistry(options?: {
+    logger?: Logger;
+}): Promise<void>;

package/dist/daemon/paths.d.ts

@@ -1,3 +1,10 @@
+export declare function getDaemonPaths(devOverride?: boolean): {
+    homeDir: string;
+    configPath: string;
+    statePath: string;
+    daemonLogDir: string;
+    userSessionLogRoot: string;
+};
 export declare const OMNARA_HOME_DIR: string;
 export declare const DAEMON_CONFIG_PATH: string;
 export declare const DAEMON_STATE_PATH: string;

package/dist/daemon/session-runner.d.ts

@@ -1,6 +1,6 @@
-import type { Logger } from '../utils/logger.js';
 import type { WorkspaceConfig } from '@omnara/shared-js/schemas';
 import { DirectoryRegistry } from './directory-registry.js';
+import { type Logger } from '../utils/logger.js';
 export interface SessionManagerOptions {
     backendUrl: string;
     frontendUrl?: string;

package/dist/env/env-mode.d.ts

@@ -0,0 +1,2 @@
+export declare function isDevEnv(): boolean;
+export declare function getOmnaraHome(devOverride?: boolean): string;

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

@@ -1,79 +1,74 @@
+import type { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
 import { type AgentClient } from './ai-client.js';
 import { Session } from './session.js';
 import { WorkerManager } from './worker-manager.js';
-import type { InboundMessage, OutboundMessage } from './orchestrator-types.js';
-import { type McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
-import type { ControlMessageSchema } from '@omnara/shared-js/schemas';
+import type { InboundMessage } from './orchestrator-types.js';
+import type { ControlMessageSchema, MessageEnvelope } from '@omnara/shared-js/schemas';
 interface AgentOrchestratorDependencies {
     createMainClient?: () => AgentClient;
     createWorkerClient?: (mcpServers?: Record<string, McpServerConfig>, cwd?: string) => AgentClient;
     workerManager?: WorkerManager;
     repoPath?: string;
-    worktreesEnabled?: boolean;
-    worktreesBaseRef?: string;
 }
-export interface AgentOrchestratorClientAdapter {
-    send: (message: OutboundMessage) => void;
+type OrchestratorControlMessage = {
+    type: 'session_init';
+    sessionId: string;
+    parentSessionId?: string | null;
+    metadata?: Record<string, unknown>;
+};
+export interface AgentOrchestratorOutputChannel {
+    sendEnvelope: (message: MessageEnvelope) => Promise<void> | void;
+    sendControl?: (message: OrchestratorControlMessage) => Promise<void> | void;
     canSend?: () => boolean;
     close?: () => void;
 }
-export interface AgentOrchestratorConnection {
-    id: string;
+export interface AgentOrchestratorInputChannel {
     dispatch(message: InboundMessage): void;
     disconnect(): void;
 }
 export declare class AgentOrchestrator {
-    private readonly completionsManager;
     private readonly aiClient;
     private readonly workerManager;
-    private readonly sessions;
     private readonly clients;
     private readonly toolUseMap;
-    private mainCodingSessionId;
-    readonly voiceSessionIds: Set<string>;
-    private readonly workerSessionIds;
+    private readonly completionsManager;
+    private session;
     private started;
+    private mainSessionId;
+    readonly voiceSessionIds: Set<string>;
     constructor(dependencies?: AgentOrchestratorDependencies);
-    ensureSessionExists(sessionId: string): Session;
-    getSession(sessionId: string): Session | undefined;
+    ensureSessionExists(requestedSessionId: string): Session;
     getWorkerManager(): WorkerManager;
     setMainCodingSessionId(sessionId: string): void;
-    addClient(adapter: AgentOrchestratorClientAdapter): AgentOrchestratorConnection;
+    addClient(output: AgentOrchestratorOutputChannel): AgentOrchestratorInputChannel;
     start(): Promise<void>;
     stop(): Promise<void>;
     cancel(): Promise<void>;
-    private handleDisconnect;
+    getCompletions(request: ControlMessageSchema.CompletionsRequest): Promise<ControlMessageSchema.CompletionsResponse>;
+    private bindSession;
+    private handleSessionControl;
+    private handleSessionMessage;
+    private handleSessionComplete;
+    private handleWorkerMessage;
+    private handleWorkerComplete;
+    private emitSessionInit;
+    private enqueueWorkerSummary;
     private handleClientMessage;
     private handleSessionInit;
     private handleChatMessage;
-    private handleJoin;
-    private handleLeave;
     private handleCancelWorker;
-    /**
-     * Route a user message directly to a worker's message queue.
-     * This allows users to send messages to subagent sessions from the frontend.
-     */
-    private routeMessageToWorker;
-    private createSession;
-    private registerToolUse;
+    private broadcastEnvelope;
+    private broadcastControl;
+    private sendToConnection;
+    private forwardEnvelope;
+    private shouldMirrorToMain;
+    private mirrorEnvelope;
+    private trackToolUse;
     private consumeToolUse;
-    private handleSessionEmpty;
-    private registerWorkerListeners;
-    private broadcastAgentProgress;
-    private buildAgentProgress;
-    private handleWorkerSessionStart;
-    private handleWorkerMessage;
-    private handleWorkerCompletion;
-    private buildWorkerSummary;
-    /**
-     * Build a comprehensive worker status message showing ALL workers,
-     * with special highlighting for the worker that triggered this generation.
-     */
-    private buildWorkerStatusMessage;
-    private broadcastToAll;
     private findSessionIdBySdkSession;
-    private sendToConnection;
-    getCompletions(request: ControlMessageSchema.CompletionsRequest): Promise<ControlMessageSchema.CompletionsResponse>;
+    private buildSystemPrompt;
+    private buildCurrentWorkerStatus;
+    private escapeXml;
 }
 export declare function startAgentOrchestrator(dependencies?: AgentOrchestratorDependencies): Promise<AgentOrchestrator>;
-export {};
+export type { OrchestratorControlMessage };

package/dist/orchestrator/ai-client.d.ts

@@ -1,20 +1,21 @@
-import { type Options, type Query, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { type Options, type SDKMessage, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 export interface AIClientConfig {
     defaults?: Partial<Options>;
 }
 export interface AgentClient {
-    streamUserMessage(prompt: string, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
-    createQuery(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): Query;
+    isGenerating(): boolean;
+    streamUserMessage(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
     cancel(): Promise<void>;
 }
 export declare const BASE_ALLOWED_ORCHESTRATOR_TOOLS: readonly ["Glob", "Grep", "LS", "Read", "WebFetch", "WebSearch", "TodoWrite"];
 export declare const BASE_ALLOWED_WORKER_TOOLS: readonly ["Task", "Bash", "Glob", "Grep", "LS", "ExitPlanMode", "Read", "Edit", "MultiEdit", "Write", "NotebookEdit", "WebFetch", "TodoWrite", "WebSearch", "BashOutput", "KillBash", "Skill", "SlashCommand"];
 export declare class AIClient implements AgentClient {
     private readonly baseOptions;
-    private runningQuery?;
+    private query?;
     constructor(config?: AIClientConfig);
-    streamUserMessage(prompt: string, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
-    createQuery(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): Query;
+    streamUserMessage(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;
+    private createQuery;
     cancel(): Promise<void>;
+    isGenerating(): boolean;
     private ensureWorkingDirectory;
 }

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

@@ -14,14 +14,14 @@ export declare const inboundMessageSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
     senderId: z.ZodOptional<z.ZodString>;
     senderKind: z.ZodOptional<z.ZodEnum<["user", "agent_session"]>>;
 }, "strip", z.ZodTypeAny, {
-    type: "chat";
     text: string;
+    type: "chat";
     sessionId?: string | undefined;
     senderId?: string | undefined;
     senderKind?: "user" | "agent_session" | undefined;
 }, {
-    type: "chat";
     text: string;
+    type: "chat";
     sessionId?: string | undefined;
     senderId?: string | undefined;
     senderKind?: "user" | "agent_session" | undefined;
@@ -101,6 +101,7 @@ export type OutboundMessage = {
     origin?: 'user' | 'worker';
     workerId?: string;
     workerTask?: string;
+    metadata?: Record<string, unknown>;
     messageId?: string;
 } | {
     type: 'assistant_text';

package/dist/orchestrator/session.d.ts

@@ -1,41 +1,62 @@
+import { type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { AgentClient } from './ai-client.js';
-import type { SessionSubscriber } from './orchestrator-types.js';
-type StreamEvent = {
-    type: string;
-    [key: string]: unknown;
-};
-type ToolUseCallback = (toolUseId: string, sessionId: string) => void;
-export declare class Session {
-    readonly id: string;
-    private readonly aiClient;
-    private readonly subscribers;
-    private readonly onEmpty;
-    private readonly onToolUse?;
-    private readonly logger;
-    private sdkSessionId;
-    private inflight;
-    private lastActivity;
-    constructor(id: string, aiClient: AgentClient, onEmpty: (sessionId: string) => void, onToolUse?: ToolUseCallback);
-    announceInboundMessage(text: string, origin?: 'user' | 'worker', workerId?: string, workerTask?: string): void;
-    get lastActiveAt(): number;
-    get sdkSessionIdentifier(): string | null;
-    subscribe(subscriber: SessionSubscriber): void;
-    unsubscribe(subscriberId: string): void;
-    hasSubscribers(): boolean;
-    close(): void;
-    enqueueUserMessage(text: string, metadata?: {
-        triggeredBy?: string;
-        workerId?: string;
-        workerTask?: string;
-    }): void;
-    handleStreamEvent(event: StreamEvent): void;
-    private processUserMessage;
-    private routeSdkMessage;
-    private handleAssistantMessage;
-    private handleResultMessage;
-    private handleSystemMessage;
-    logInbound(payload: unknown): void;
-    private broadcast;
-    private safeSend;
+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 announcementPromise;
+    private announced;
+    private shouldSummarize;
+    private systemPromptProvider?;
+    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 summarize;
+    private emitProgress;
+    onEnvelope(cb: (msg: MessageEnvelope) => void | Promise<void>): void;
+    onSessionInit(cb: (control: SessionInitNotification) => void | Promise<void>): void;
+    setSystemPromptProvider(provider: () => string | Promise<string>): void;
+    cancel(): Promise<void>;
+    private dispatchEnvelope;
+    private emitSessionInit;
 }
 export {};

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

@@ -1,4 +1,6 @@
 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;

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

@@ -0,0 +1,13 @@
+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,3 +1,2 @@
-export { WorktreeManager, WorktreeError, type WorktreeManagerOptions, type WorktreeInfo, } from './worktree-manager.js';
-export { AsyncQueue } from './async-queue.js';
+export { WorktreeManager } from './worktree-manager.js';
 export type { SessionLogger } from './session-logger.js';

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

@@ -0,0 +1,7 @@
+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,153 +1,27 @@
 import { type SimpleGit } from 'simple-git';
-/**
- * Configuration options for WorktreeManager
- */
-export interface WorktreeManagerOptions {
-    /**
-     * The root directory of the git repository
-     */
-    repoPath: string;
-    /**
-     * Base directory for worktrees (default: .omnara/worktrees)
-     */
-    worktreeBasePath?: string;
-    /**
-     * Whether worktrees are enabled (default: false)
-     */
-    enabled?: boolean;
-    /**
-     * Base ref to use when creating new branches (optional)
-     */
-    base_ref?: string;
-}
-/**
- * Information about a created worktree
- */
-export interface WorktreeInfo {
-    /**
-     * Unique identifier for the worker
-     */
-    workerId: string;
-    /**
-     * Semantic name for the worktree (e.g., "main-feature", "bugfix-auth")
-     */
-    worktreeName: string;
-    /**
-     * Absolute path to the worktree directory
-     */
-    worktreePath: string;
-    /**
-     * Name of the branch created for this worktree
-     */
-    branchName: string;
-    /**
-     * Timestamp when the worktree was created
-     */
-    createdAt: Date;
-}
-/**
- * Error thrown when worktree operations fail
- */
-export declare class WorktreeError extends Error {
-    readonly workerId: string;
-    readonly operation: string;
-    readonly cause?: Error | undefined;
-    constructor(message: string, workerId: string, operation: string, cause?: Error | undefined);
-}
-/**
- * Manages git worktrees for worker isolation
- *
- * This class handles the lifecycle of git worktrees, ensuring each worker
- * operates in an isolated environment. It provides methods for creating,
- * managing, and cleaning up worktrees.
- *
- * @example
- * ```typescript
- * const manager = new WorktreeManager({ repoPath: '/path/to/repo' });
- * const info = await manager.createWorktree('worker-123', 'main-feature');
- * // Worker operates in info.worktreePath
- * await manager.removeWorktree('worker-123');
- * ```
- */
+import type { WorkspaceConfigSchema } from '@omnara/shared-js/schemas';
 export declare class WorktreeManager {
+    private repoPath;
     readonly git: SimpleGit;
-    private readonly repoPath;
-    private readonly worktreeBasePath;
-    private readonly activeWorktrees;
-    private readonly enabled;
-    private readonly base_ref?;
-    private readonly creationQueue;
-    private isProcessingQueue;
-    private readonly worktreesByName;
-    constructor(options: WorktreeManagerOptions);
-    /**
-     * 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
-     */
-    findValidBaseRef(): Promise<string | undefined>;
-    /**
-     * Validate that the repoPath is a git repository
-     * Logs an error if worktrees are enabled but not in a git repository
-     */
-    private validateGitRepository;
-    /**
-     * Check if worktrees are enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Creates a new worktree for the specified worker
-     *
-     * This method uses a sequential queue to ensure that worktree creation
-     * happens one at a time, eliminating race conditions when multiple workers
-     * request the same worktree simultaneously.
-     *
-     * @param workerId - Unique identifier for the worker
-     * @param worktreeName - Semantic name for the worktree (e.g., "main-feature", "bugfix-auth")
-     * @returns Information about the created worktree
-     * @throws {WorktreeError} If worktree creation fails
-     */
-    createWorktree(workerId: string, worktreeName: string): Promise<WorktreeInfo>;
-    /**
-     * Processes the creation queue sequentially
-     * Ensures only one worktree creation happens at a time
-     */
-    private processCreationQueue;
+    private repoName;
+    private readonly worktrees;
+    private worktreeUsers;
+    private worktreeBasePath;
+    constructor(repoPath: string);
+    getWorktreeConfig(): Promise<WorkspaceConfigSchema.WorktreeSettings | undefined>;
+    getWorktreeDirectory(worktreeName: string, workerId: string): Promise<string>;
     /**
      * Internal method that performs the actual worktree creation
      * This should only be called by processCreationQueue
      */
-    private doCreateWorktree;
-    /**
-     * Removes a worktree for the specified worker
-     *
-     * @param workerId - Unique identifier for the worker
-     * @param force - Force removal even if there are uncommitted changes
-     * @throws {WorktreeError} If worktree removal fails
-     */
-    removeWorktree(workerId: string, force?: boolean): Promise<void>;
-    /**
-     * Gets information about a worker's worktree
-     *
-     * @param workerId - Unique identifier for the worker
-     * @returns Worktree information or undefined if not found
-     */
-    getWorktreeInfo(workerId: string): WorktreeInfo | undefined;
-    /**
-     * Lists all active worktrees managed by this instance
-     *
-     * @returns Array of worktree information
-     */
-    listActiveWorktrees(): WorktreeInfo[];
-    /**
-     * Cleans up all active worktrees
-     *
-     * This method should be called during application shutdown to ensure
-     * all worktrees are properly cleaned up.
-     *
-     * @param force - Force removal even if there are uncommitted changes
-     */
+    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'
      *
@@ -156,9 +30,10 @@ export declare class WorktreeManager {
      */
     private parseWorktreeList;
     /**
-     * Checks if the repository is in a clean state for worktree operations
-     *
-     * @returns True if repository is clean
+     * 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
      */
-    isRepositoryClean(): Promise<boolean>;
+    private findValidBaseRef;
+    commitChanges(worktreeName?: string, message?: string): Promise<void>;
 }