omnara 0.1.11 → 0.2.0

package/dist/commands/agent.d.ts

@@ -1,7 +1,8 @@
-import { Command } from 'commander';
-export declare function buildAgentCommand(): Command;
 export interface OrchestratorOptions {
     backendUrl?: string;
     frontendUrl?: string;
+    workspaceId?: string;
+    userSessionId?: string;
+    agentSessionId?: string;
 }
 export declare function runAgentOrchestrator(options?: OrchestratorOptions): Promise<void>;

package/dist/commands/daemon.d.ts

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

package/dist/commands/index.d.ts

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

package/dist/config/omnara-config.d.ts

@@ -1,27 +1,7 @@
 import * as z from 'zod';
+import type { WorkspaceConfigSchema } from '@omnara/shared-js/schemas';
+declare const OmnaraConfig: z.ZodType<WorkspaceConfigSchema.WorkspaceConfig>;
 export type OmnaraConfig = z.infer<typeof OmnaraConfig>;
-declare const OmnaraConfig: z.ZodObject<{
-    worktrees: z.ZodDefault<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        base_ref: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-        base_ref?: string | undefined;
-    }, {
-        enabled?: boolean | undefined;
-        base_ref?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    worktrees: {
-        enabled: boolean;
-        base_ref?: string | undefined;
-    };
-}, {
-    worktrees?: {
-        enabled?: boolean | undefined;
-        base_ref?: string | undefined;
-    } | undefined;
-}>;
 /**
  * Read and parse the omnara.jsonc configuration file
  *

package/dist/daemon/config-store.d.ts

@@ -0,0 +1,37 @@
+export interface DirectoryEntry {
+    id: string;
+    path: string;
+    label?: string;
+    addedAt: string;
+    lastUsedAt?: string;
+}
+export interface MachineMetadata {
+    id?: string;
+    name?: string;
+    token?: string;
+    lastSeenAt?: string;
+    tokenExpiresAt?: string;
+}
+export interface DaemonSettings {
+    maxSessions?: number;
+    autoUpdateCheckSeconds?: number;
+}
+export interface DaemonConfigData {
+    machine?: MachineMetadata;
+    directories: DirectoryEntry[];
+    settings?: DaemonSettings;
+}
+export declare class DaemonConfigStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<DaemonConfigData>;
+    save(config: DaemonConfigData): Promise<void>;
+    update(mutate: (config: DaemonConfigData) => void | DaemonConfigData): Promise<DaemonConfigData>;
+    ensureDirectory(absolutePath: string, options?: {
+        label?: string;
+        touch?: boolean;
+    }): Promise<{
+        entry: DirectoryEntry;
+        created: boolean;
+    }>;
+}

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

@@ -0,0 +1,26 @@
+import type { DirectoryEntry } from './config-store.js';
+import type { DaemonStatusPayload, LaunchWorkspaceResult } from './local-control-server.js';
+import { DaemonStateStore } from './state-store.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export declare class DaemonClient {
+    private readonly stateStore;
+    constructor(stateStore?: DaemonStateStore);
+    getStatus(): Promise<DaemonStatusPayload | null>;
+    addDirectory(directoryPath: string, label?: string): Promise<{
+        directory: DirectoryEntry;
+        created: boolean;
+    } | null>;
+    stop(status?: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<boolean>;
+    launchSession(options: {
+        path: string;
+        initialPrompt?: string;
+        userSessionId?: string;
+    }): Promise<LaunchWorkspaceResult | null>;
+    private getEndpoint;
+    private request;
+}
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly body?: string | undefined;
+    constructor(message: string, statusCode: number, body?: string | undefined);
+}

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

@@ -0,0 +1,30 @@
+import type { Logger } from '../utils/logger.js';
+export interface StartDaemonOptions {
+    waitForReady?: boolean;
+    reason?: string;
+    backendUrl?: string;
+    frontendUrl?: string;
+    logger?: Logger;
+}
+export interface StopDaemonOptions {
+    logger?: Logger;
+}
+export interface EnsureDaemonOptions {
+    cwd?: string;
+    label?: string;
+    reason?: string;
+    backendUrl?: string;
+    frontendUrl?: string;
+    logger?: Logger;
+}
+export interface StatusOptions {
+    logger?: Logger;
+}
+export interface KillAllOptions {
+    logger?: Logger;
+}
+export declare function ensureDaemonForSession(options?: EnsureDaemonOptions): Promise<void>;
+export declare function startDaemon(options?: StartDaemonOptions): Promise<boolean>;
+export declare function stopDaemon(options?: StopDaemonOptions): Promise<boolean>;
+export declare function showDaemonStatus(options?: StatusOptions): Promise<void>;
+export declare function killAllDaemonProcesses(options?: KillAllOptions): Promise<void>;

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

@@ -0,0 +1,30 @@
+import type { Logger } from '../utils/logger.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import { DaemonStateStore } from './state-store.js';
+import { MachineSupervisor } from './machine-supervisor.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface DaemonServiceOptions {
+    directoryRegistry?: DirectoryRegistry;
+    stateStore?: DaemonStateStore;
+    machineSupervisor?: MachineSupervisor;
+    logger?: Logger;
+}
+export declare class DaemonService {
+    private readonly logger;
+    private readonly directoryRegistry;
+    private readonly stateStore;
+    private readonly machineSupervisor;
+    private controlHandle;
+    private startedAt;
+    private stopPromise;
+    private resolveStopPromise;
+    private stopping;
+    constructor(options?: DaemonServiceOptions);
+    start(): Promise<void>;
+    stop(status?: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<void>;
+    waitForShutdown(): Promise<void>;
+    private buildStatusPayload;
+    private handleLaunchRequest;
+    private persistState;
+    private cleanupState;
+}

package/dist/daemon/directory-registry.d.ts

@@ -0,0 +1,17 @@
+import { DaemonConfigStore, type DirectoryEntry } from './config-store.js';
+export interface DirectoryEnsureOptions {
+    label?: string;
+    updateLastUsed?: boolean;
+    skipValidation?: boolean;
+}
+export declare class DirectoryRegistry {
+    private readonly store;
+    constructor(store?: DaemonConfigStore);
+    list(): Promise<DirectoryEntry[]>;
+    getEntry(directoryPath: string): Promise<DirectoryEntry | null>;
+    ensureDirectory(directoryPath: string, options?: DirectoryEnsureOptions): Promise<{
+        entry: DirectoryEntry;
+        created: boolean;
+    }>;
+    private assertDirectory;
+}

package/dist/daemon/file-logger.d.ts

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import { ControlledLogger, LogLevel } from '../utils/logger.js';
+export declare class FileBackedLogger extends ControlledLogger {
+    private readonly stream;
+    private closed;
+    constructor(stream: fs.WriteStream, options?: {
+        logLevel?: LogLevel;
+        forceOutput?: boolean;
+    });
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    important(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    close(): Promise<void>;
+    private writeLine;
+}
+export declare function createDaemonFileLogger(): Promise<{
+    logger: FileBackedLogger;
+    logPath: string;
+}>;

package/dist/daemon/local-control-server.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from '../utils/logger.js';
+import type { DirectoryEntry } from './config-store.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface DaemonStatusPayload {
+    pid: number;
+    startedAt: string;
+    directories: DirectoryEntry[];
+}
+export interface LocalControlServerOptions {
+    directoryRegistry: DirectoryRegistry;
+    getStatus: () => Promise<DaemonStatusPayload>;
+    onStopRequested: (status: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>) => Promise<void> | void;
+    onLaunchRequested?: (payload: LaunchWorkspacePayload) => Promise<LaunchWorkspaceResult>;
+    logger?: Logger;
+}
+export interface LocalControlServerHandle {
+    port: number;
+    token: string;
+    close(): Promise<void>;
+}
+export interface LaunchWorkspacePayload {
+    path: string;
+    initialPrompt?: string;
+    userSessionId?: string;
+}
+export interface LaunchWorkspaceSuccessPayload {
+    user_session_id: string;
+    workspace_id: string;
+    launch_id: string;
+}
+export interface LaunchWorkspaceResult {
+    status: 'ok' | 'error' | string;
+    payload?: LaunchWorkspaceSuccessPayload | null;
+    error?: string;
+}
+export declare function startLocalControlServer(options: LocalControlServerOptions): Promise<LocalControlServerHandle>;

package/dist/daemon/machine-supervisor.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from '../utils/logger.js';
+import { DirectoryRegistry } from './directory-registry.js';
+import { DaemonConfigStore } from './config-store.js';
+import type { AuthProvider } from '../auth/auth-provider.js';
+import type { LaunchWorkspaceResult } from './local-control-server.js';
+import type { MachineMessageSchema } from '../../../shared-js/dist/schemas/generated.js';
+export interface MachineSupervisorOptions {
+    backendUrl: string;
+    frontendUrl?: string;
+    directoryRegistry: DirectoryRegistry;
+    configStore: DaemonConfigStore;
+    authProvider: AuthProvider;
+    logger?: Logger;
+}
+export declare class MachineSupervisor {
+    private readonly backendUrl;
+    private readonly frontendUrl?;
+    private readonly directoryRegistry;
+    private readonly configStore;
+    private readonly authProvider;
+    private readonly apiClient;
+    private readonly logger;
+    private readonly sessionManager;
+    private running;
+    private stopRequested;
+    private loopPromise;
+    private websocket;
+    private heartbeatTimer;
+    private waitingForLogin;
+    private machineRegistrationReady;
+    constructor(options: MachineSupervisorOptions);
+    start(): Promise<void>;
+    launchWorkspaceSessionLocal(options: {
+        path: string;
+        initialPrompt?: string;
+        userSessionId?: string;
+    }): Promise<LaunchWorkspaceResult>;
+    stop(status: Exclude<MachineMessageSchema.MachineStatus, 'ONLINE'>): Promise<void>;
+    private runLoop;
+    private registerMachine;
+    private runWebsocket;
+    private handleSocketMessage;
+    private handleRpcRequest;
+    private sendRpcResponse;
+    private launchWorkspaceSessionFromRpc;
+    private launchWorkspaceSession;
+    private ensureWorkspaceForDirectory;
+    private ensureWorkspaceWithRetry;
+    private ensureUserSessionForWorkspace;
+    private buildWorkspaceMetadata;
+    private getMachineId;
+    private waitForMachineRegistration;
+    private startHeartbeatTimer;
+    private clearHeartbeatTimer;
+    private sendHeartbeat;
+    private sendMessage;
+    private clearLoginWait;
+    private closeWebsocket;
+    private recoverMachineRegistration;
+}

package/dist/daemon/paths.d.ts

@@ -0,0 +1,9 @@
+export declare const OMNARA_HOME_DIR: string;
+export declare const DAEMON_CONFIG_PATH: string;
+export declare const DAEMON_STATE_PATH: string;
+export declare const DAEMON_LOG_DIR: string;
+export declare const USER_SESSION_LOG_ROOT: string;
+export declare const DEFAULT_DIR_MODE = 448;
+export declare const DEFAULT_FILE_MODE = 384;
+export declare function ensureOmnaraHome(): Promise<void>;
+export declare function ensureDirectory(dirPath: string): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function runDaemonProcess(): Promise<void>;

package/dist/daemon/session-log-manager.d.ts

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+export interface SessionLogHandle {
+    stream: fs.WriteStream;
+    logPath: string;
+}
+export declare function createSessionLog(handle: {
+    workspaceId: string;
+    launchId: string;
+}): Promise<SessionLogHandle>;
+export declare function writeSessionLog(stream: fs.WriteStream, level: string, args: unknown[]): void;

package/dist/daemon/session-pid-registry.d.ts

@@ -0,0 +1,5 @@
+export interface SessionRegistry {
+    [userSessionId: string]: number;
+}
+export declare function withSessionRegistry<T>(fn: (registry: SessionRegistry) => Promise<[SessionRegistry, T]> | [SessionRegistry, T]): Promise<T>;
+export declare function isProcessAlive(pid: number): Promise<boolean>;

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

@@ -0,0 +1,28 @@
+import type { Logger } from '../utils/logger.js';
+import type { WorkspaceConfig } from '@omnara/shared-js/schemas';
+import { DirectoryRegistry } from './directory-registry.js';
+export interface SessionManagerOptions {
+    backendUrl: string;
+    frontendUrl?: string;
+    directoryRegistry: DirectoryRegistry;
+    logger: Logger;
+}
+export interface SessionLaunchSpec {
+    launchId: string;
+    directory: string;
+    userSessionId: string;
+    workspaceId: string;
+    workspaceConfig?: WorkspaceConfig | null;
+    initialPrompt?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export declare class SessionManager {
+    private readonly backendUrl;
+    private readonly frontendUrl?;
+    private readonly directoryRegistry;
+    private readonly logger;
+    private readonly runners;
+    constructor(options: SessionManagerOptions);
+    startSession(spec: SessionLaunchSpec): Promise<void>;
+    stopAll(): Promise<void>;
+}

package/dist/daemon/state-store.d.ts

@@ -0,0 +1,14 @@
+export interface DaemonStateData {
+    pid: number;
+    port: number;
+    token: string;
+    startedAt: string;
+    version?: string;
+}
+export declare class DaemonStateStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    load(): Promise<DaemonStateData | null>;
+    save(state: DaemonStateData): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/http/machines.d.ts

@@ -0,0 +1,3 @@
+import { ApiClient } from './api-client.js';
+import type { MachineRegisterRequest, MachineRegisterResponse } from '@omnara/shared-js/schemas';
+export declare function registerMachine(client: ApiClient, accessToken: string, payload: MachineRegisterRequest): Promise<MachineRegisterResponse>;

package/dist/http/user-sessions.d.ts

@@ -7,7 +7,10 @@ export interface UserSessionDescriptor {
     name?: string | null;
     metadata?: Record<string, unknown> | null;
 }
-export declare function createUserSession(client: ApiClient, accessToken: string, options?: {
+export interface EnsureUserSessionOptions {
+    workspaceId: string;
+    userSessionId?: string;
     name?: string;
     metadata?: Record<string, unknown>;
-}): Promise<UserSessionDescriptor>;
+}
+export declare function ensureUserSession(client: ApiClient, accessToken: string, options: EnsureUserSessionOptions): Promise<UserSessionDescriptor>;

package/dist/http/workspaces.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceDescriptor, WorkspaceEnsureRequest, WorkspaceSessionLaunchRequest, WorkspaceSessionLaunchResponse } from '@omnara/shared-js/schemas';
+import { ApiClient } from './api-client.js';
+export declare function ensureWorkspace(client: ApiClient, accessToken: string, payload: WorkspaceEnsureRequest): Promise<WorkspaceDescriptor>;
+export declare function launchWorkspaceSession(client: ApiClient, accessToken: string, workspaceId: string, payload: WorkspaceSessionLaunchRequest): Promise<WorkspaceSessionLaunchResponse>;

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

@@ -1,3 +1,4 @@
+import { type SimpleGit } from 'simple-git';
 /**
  * Configuration options for WorktreeManager
  */
@@ -69,7 +70,7 @@ export declare class WorktreeError extends Error {
  * ```
  */
 export declare class WorktreeManager {
-    private readonly git;
+    readonly git: SimpleGit;
     private readonly repoPath;
     private readonly worktreeBasePath;
     private readonly activeWorktrees;
@@ -84,7 +85,7 @@ export declare class WorktreeManager {
      * Tries in order: configured base_ref, main, master, origin/HEAD
      * @returns The first valid ref found, or undefined if none exist
      */
-    private findValidBaseRef;
+    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

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

@@ -2,6 +2,7 @@ import { EventEmitter } from 'events';
 import type { SDKUserMessage, McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
 import type { AgentClient } from './ai-client.js';
 import { AsyncQueue } from './utils/async-queue.js';
+import { WorktreeManager } from './utils/worktree-manager.js';
 export type WorkerStatus = 'running' | 'completed' | 'error' | 'canceled';
 export interface WorkerProgressEntry {
     timestamp: number;
@@ -57,7 +58,9 @@ export declare class WorkerManager extends EventEmitter {
     private readonly workers;
     private readonly runningQueries;
     private worktreeManager;
+    repoPath: string;
     constructor(options: WorkerManagerOptions);
+    private initializeConfig;
     listWorkers(): WorkerRecord[];
     getWorker(id: string): WorkerRecord | undefined;
     getWorkerByTask(task: string): WorkerRecord | undefined;
@@ -99,5 +102,10 @@ export declare class WorkerManager extends EventEmitter {
      * This should be called during application shutdown to ensure all worktrees are cleaned up
      */
     shutdown(): Promise<void>;
+    /**
+     * Get the WorktreeManager instance
+     * @returns The WorktreeManager instance
+     */
+    getWorktreeManager(): WorktreeManager;
 }
 export {};

package/dist/package-info.d.ts

@@ -0,0 +1,3 @@
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
+export declare const PACKAGE_DESCRIPTION: string;

package/dist/relay/relay-bridge.d.ts

@@ -6,6 +6,9 @@ export interface RelayBridgeOptions {
     logger?: Console;
     backendUrl: string;
     frontendUrl?: string;
+    workspaceId?: string;
+    userSessionId?: string;
+    agentSessionId?: string;
 }
 export declare class RelayBridge extends EventEmitter {
     private readonly orchestrator;
@@ -13,6 +16,7 @@ export declare class RelayBridge extends EventEmitter {
     private readonly logger;
     private readonly backendUrl;
     private readonly frontendUrl?;
+    private readonly workspaceId;
     private connectionHandle;
     private ws;
     private stopped;
@@ -22,8 +26,10 @@ export declare class RelayBridge extends EventEmitter {
     private authProviderPromise;
     private userSessionId;
     private currentAgentSessionId;
+    private readonly attachAgentSessionId;
     private browserOpened;
     private canceled;
+    private waitingForLogin;
     constructor(orchestrator: AgentOrchestrator, options: RelayBridgeOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -44,6 +50,7 @@ export declare class RelayBridge extends EventEmitter {
     private handleSessionAnnounce;
     private handleCancelAgent;
     private handleSessionClosed;
+    private handleGitDiffRequest;
     private handleRelayRequest;
     private handleMessageEnvelope;
     private isTextContent;
@@ -59,5 +66,6 @@ export declare class RelayBridge extends EventEmitter {
     private enqueue;
     private flushQueue;
     private startPingTimer;
+    private clearLoginWait;
     private closeCurrentSocket;
 }

package/dist/schemas/index.d.ts

@@ -1,2 +1,2 @@
-export type { ControlMessage, MessageEnvelope, ControlMessageSchema, MessageEnvelopeSchema, ValidationError, } from '@omnara/shared-js/schemas';
-export { validateControlMessage, validateMessageEnvelope } from '@omnara/shared-js/schemas';
+export type { ControlMessage, MessageEnvelope, ControlMessageSchema, MessageEnvelopeSchema, MachineMessage, ValidationError, } from '@omnara/shared-js/schemas';
+export { validateControlMessage, validateMessageEnvelope, validateMachineMessage, } from '@omnara/shared-js/schemas';

package/dist/utils/claude-code-check.d.ts

@@ -1,25 +1,6 @@
-/**
- * Checks if Claude Code is installed and available in the system
- */
-export declare function checkClaudeCodeInstallation(): boolean;
-/**
- * Checks if ANTHROPIC_API_KEY environment variable is set
- */
-export declare function checkAnthropicApiKey(): boolean;
-/**
- * Displays a warning message if neither authentication method is available
- */
-export declare function displayClaudeCodeWarning(): void;
 /**
  * Performs the Claude Code check and displays warning if needed
  * @param options - Optional configuration for the check
  * @returns boolean indicating if either authentication method is available
  */
-export declare function performClaudeCodeCheck(options?: {
-    silent?: boolean;
-    exitOnMissing?: boolean;
-}): boolean;
-/**
- * Gets Claude Code version if installed
- */
-export declare function getClaudeCodeVersion(): string | null;
+export declare function performClaudeCodeCheck(): Promise<boolean>;

package/dist/utils/version-check.d.ts

@@ -2,8 +2,4 @@
  * Checks if a newer version is available and logs a message if so.
  * This function is non-blocking and will not throw errors.
  */
-export declare function checkForUpdates(): Promise<void>;
-/**
- * Checks for updates in the background without blocking
- */
-export declare function checkForUpdatesInBackground(): void;
+export declare function attemptUpdate(): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnara",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "type": "module",
   "description": "Command-line interface for Omnara.",
   "main": "dist/cli.js",
@@ -11,7 +11,7 @@
   "scripts": {
     "build": "npm run build:types && node build.mjs && npm run copy-assets",
     "build:types": "tsc --emitDeclarationOnly --project tsconfig.json",
-    "copy-assets": "mkdir -p dist dist/orchestrator && cp -r src/orchestrator/*.md dist/ && cp -r src/orchestrator/*.md dist/orchestrator/",
+    "copy-assets": "node scripts/copy-assets.mjs",
     "preinstall": "node scripts/preinstall.js"
   },
   "keywords": [
@@ -27,7 +27,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.23",
+    "@anthropic-ai/claude-agent-sdk": "^0.1.42",
     "@anthropic-ai/sdk": "^0.67.0",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@supabase/supabase-js": "^2.76.1",

package/scripts/copy-assets.mjs

@@ -0,0 +1,41 @@
+import { mkdir, copyFile } from 'fs/promises';
+import { basename, join } from 'path';
+import { cwd } from 'process';
+import { glob } from 'glob';
+
+async function main() {
+  const projectRoot = cwd();
+  const mdFiles = await glob('src/orchestrator/*.md', {
+    cwd: projectRoot,
+    absolute: true,
+  });
+
+  if (mdFiles.length === 0) {
+    return;
+  }
+
+  const distDir = join(projectRoot, 'dist');
+  const orchestratorDistDir = join(distDir, 'orchestrator');
+
+  await Promise.all([
+    mkdir(distDir, { recursive: true }),
+    mkdir(orchestratorDistDir, { recursive: true }),
+  ]);
+
+  await Promise.all(
+    mdFiles.flatMap((file) => {
+      const fileName = basename(file);
+      const targets = [
+        join(distDir, fileName),
+        join(orchestratorDistDir, fileName),
+      ];
+
+      return targets.map((target) => copyFile(file, target));
+    }),
+  );
+}
+
+main().catch((error) => {
+  console.error('[copy-assets] Failed to copy markdown assets:', error);
+  process.exit(1);
+});

package/dist/repl/terminal-repl.d.ts

@@ -1,9 +0,0 @@
-export interface ReplOptions {
-    url?: string;
-    headers?: Record<string, string>;
-    initialSessionId?: string;
-    parentSessionId?: string;
-    initialMetadata?: Record<string, unknown>;
-    initializeSession?: boolean;
-}
-export declare function runTerminalRepl(options?: Partial<ReplOptions>): Promise<void>;