echoclaw-relay-agent 0.22.4 → 0.22.6

package/dist/RelayAgent.js

@@ -469,11 +469,20 @@ export class RelayAgent extends EventEmitter {
         this.transport.on('connect_timeout', (timeoutMs) => {
             this.emit('error', Object.assign(new Error(`Connection timed out after ${timeoutMs / 1000}s`), { code: 'CONNECT_TIMEOUT' }));
         });
-        // Handle server fatal CLOSE messages (SESSION_NOT_FOUND, SESSION_PROTOCOL_MISMATCH, etc.)
+        // Handle server messages (DESKTOP_RECONNECTED, fatal errors, etc.)
         const SESSION_FATAL = new Set(['SESSION_NOT_FOUND', 'INVALID_SESSION', 'SESSION_PROTOCOL_MISMATCH']);
         this.transport.on('message', (msg) => {
             if ((msg.type === 'CLOSE' || msg.type === 'STATUS') && msg.sender_role === 'server') {
                 const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                // Desktop restarted — reset FrameCrypto receive sequence counter.
+                // Desktop creates a new FrameCrypto on resumeSession() (sendSeq starts at 0),
+                // but Agent's FrameCrypto still has recvHighestSeq from the old session.
+                // Without this reset, all messages from Desktop are rejected as "Sequence regression".
+                if (payload === 'DESKTOP_RECONNECTED') {
+                    this.frameCrypto?.reset();
+                    this.emit('peer_reconnected');
+                    return;
+                }
                 if (payload === 'UNPAIRED' || SESSION_FATAL.has(payload)) {
                     this.sessionStore.clear().catch(() => { });
                     this._paired = false;

package/dist/RelayClient.js

@@ -399,6 +399,14 @@ export class RelayClient extends EventEmitter {
         this.transport.on('message', (msg) => {
             if ((msg.type === 'CLOSE' || msg.type === 'STATUS') && msg.sender_role === 'server') {
                 const payload = typeof msg.payload === 'string' ? msg.payload : '';
+                // Agent restarted — reset FrameCrypto receive sequence counter.
+                // Same issue as DESKTOP_RECONNECTED: Agent creates new FrameCrypto on restart
+                // (sendSeq starts at 0), but Desktop's recvHighestSeq is still from old session.
+                if (payload === 'AGENT_RESTARTED') {
+                    this.frameCrypto?.reset();
+                    this.emit('peer_reconnected');
+                    return;
+                }
                 if (PEER_STATUS.has(payload)) {
                     this.emit('peer_status', {
                         status: payload === 'AGENT_ONLINE' ? 'online' : 'warning',

package/dist/cli.js

@@ -97,6 +97,9 @@ function parseArgs(argv) {
         else if (arg === 'status') {
             command = 'status';
         }
+        else if (arg === 'restart') {
+            command = 'restart';
+        }
         else if (arg === 'uninstall') {
             command = 'uninstall';
         }
@@ -171,6 +174,7 @@ ${BOLD}EchoClaw Relay Agent${RESET}
 ${BOLD}Usage:${RESET}
   ${CYAN}echoclaw-relay setup <CODE>${RESET}       Pair + install as system service (${BOLD}recommended${RESET})
   ${CYAN}echoclaw-relay status${RESET}             Show service status
+  ${CYAN}echoclaw-relay restart${RESET}            Restart system service
   ${CYAN}echoclaw-relay uninstall${RESET}          Remove system service
 
 ${BOLD}Setup Options:${RESET}
@@ -423,6 +427,31 @@ async function runStatus() {
     }
     console.log();
 }
+async function runRestart() {
+    printLogo();
+    const svc = await getServiceManager();
+    const st = await svc.status();
+    if (!st.installed) {
+        console.log(`  ${RED}Service not installed.${RESET}`);
+        console.log(`  Run ${CYAN}echoclaw-relay setup <CODE>${RESET} first.\n`);
+        process.exit(1);
+    }
+    console.log(`  Restarting service...`);
+    await svc.restart();
+    // Brief wait for process to come up
+    await new Promise(r => setTimeout(r, 1500));
+    const after = await svc.status();
+    if (after.running) {
+        console.log(`  ${GREEN}${BOLD}Service restarted successfully.${RESET}`);
+        if (after.pid)
+            console.log(`  PID: ${after.pid}`);
+    }
+    else {
+        console.log(`  ${YELLOW}Service restarted but may still be starting up.${RESET}`);
+        console.log(`  Run ${CYAN}echoclaw-relay status${RESET} to check.`);
+    }
+    console.log();
+}
 async function runUninstall() {
     printLogo();
     const svc = await getServiceManager();
@@ -745,6 +774,9 @@ async function main() {
         else if (opts.command === 'status') {
             await runStatus();
         }
+        else if (opts.command === 'restart') {
+            await runRestart();
+        }
         else if (opts.command === 'uninstall') {
             await runUninstall();
         }

package/dist/install/InstallHandler.d.ts

@@ -44,6 +44,10 @@ export declare class InstallHandler {
     private _runToRequest;
     /** Whether workspace docs have been synced to OpenClaw. */
     private _workspaceSynced;
+    /** ICP workspace orchestrator for engine-based flows. */
+    private readonly _icpOrchestrator;
+    /** Actions that should be routed through ICP workspace flow. */
+    private static readonly ICP_ACTIONS;
     constructor(wsClient: OpenClawWsClient, chatHandler: ChatHandler, config?: InstallHandlerConfig);
     /** Set the callback for sending messages back to Desktop. */
     setSendBack(fn: (msg: Record<string, unknown>) => Promise<void>): void;
@@ -62,6 +66,25 @@ export declare class InstallHandler {
     handleAbort(requestId: string): Promise<void>;
     /** Disconnect and clean up all active installs. */
     cleanup(): void;
+    /**
+     * Handle an install request through the ICP workspace orchestrator.
+     * On timeout, falls back to the chat-based flow.
+     */
+    private _handleViaIcp;
+    /**
+     * Build an IcpRequest from an InstallRequest payload.
+     * Returns null if the payload can't be mapped to an ICP request.
+     */
+    private _buildIcpRequest;
+    /**
+     * Fall back to the existing chat-based flow.
+     * Called when ICP times out or can't handle the request.
+     */
+    private _handleViaChatFallback;
+    /**
+     * Generate human-readable message for ICP progress phases.
+     */
+    private _icpPhaseMessage;
     /**
      * Handle a streaming chat event for an install run.
      * Called when a chat event arrives with a runId we're tracking.

package/dist/install/InstallHandler.js

@@ -23,6 +23,8 @@ import crypto from 'node:crypto';
 import { buildAppRequestPrompt } from '../gateway/AppRequestPrompt.js';
 import { StreamingMarkerParser } from './MarkerParser.js';
 import { INSTALL_ERROR_CODES, } from './types.js';
+import { IcpOrchestrator, } from '@echoclaw/icp-orchestrator';
+import { resolveInstallAction, } from '@echoclaw/claw-engine';
 // ── Constants ────────────────────────────────────────────────────
 const DEFAULT_TIMEOUT_MS = 120000;
 const DEFAULT_RPC_TIMEOUT_MS = 30000;
@@ -90,11 +92,23 @@ export class InstallHandler {
             writable: true,
             value: false
         });
+        /** ICP workspace orchestrator for engine-based flows. */
+        Object.defineProperty(this, "_icpOrchestrator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this._wsClient = wsClient;
         this._chatHandler = chatHandler;
         this._timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         this._sessionKey = config?.sessionKey ?? DEFAULT_SESSION_KEY;
         this._rpcTimeoutMs = config?.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+        // Initialize ICP orchestrator
+        this._icpOrchestrator = new IcpOrchestrator({
+            outputTimeoutMs: this._timeoutMs,
+            reviewTimeoutMs: this._timeoutMs,
+        });
         // Listen for chat events — only process runs we own
         this._wsClient.on('chat', (payload) => {
             const runId = payload?.runId;
@@ -149,6 +163,41 @@ export class InstallHandler {
             requestId,
             status: 'accepted',
         });
+        // ── ICP workspace routing ────────────────────────────────────
+        // Route eligible actions through ICP orchestrator (workspace-based).
+        // Falls back to chat-based on timeout/failure.
+        if (InstallHandler.ICP_ACTIONS.has(action) && this._workspaceSynced) {
+            // Track in _activeInstalls to prevent duplicates and support abort
+            const icpAbort = new AbortController();
+            const icpInstall = {
+                requestId,
+                action,
+                runId: null,
+                parser: new StreamingMarkerParser(),
+                startedAt: Date.now(),
+                timeoutTimer: null,
+                lastKnownLength: 0,
+                legacy,
+                lastStatusAt: 0,
+                streamMarkers: [],
+                hasConfirmedPlan: false,
+                icpAbort,
+            };
+            this._activeInstalls.set(requestId, icpInstall);
+            this._handleViaIcp(requestId, action, payload, icpAbort.signal).catch((err) => {
+                // ICP flow threw unexpectedly — send failure to Desktop
+                this._send({
+                    type: 'install_result',
+                    requestId,
+                    status: 'failed',
+                    error: err?.message || 'ICP orchestration failed unexpectedly',
+                    code: INSTALL_ERROR_CODES.ICP_FAILED,
+                }).catch(() => { });
+                this._activeInstalls.delete(requestId);
+            });
+            return;
+        }
+        // ── Chat-based flow (legacy / preview / execute-with-plan) ──
         // Create active install tracker
         const install = {
             requestId,
@@ -162,6 +211,7 @@ export class InstallHandler {
             lastStatusAt: 0,
             streamMarkers: [],
             hasConfirmedPlan: !!(action === 'install' && payload.confirmedPlan),
+            icpAbort: null,
         };
         this._activeInstalls.set(requestId, install);
         // Build prompt from the install/adapt/preview payload
@@ -224,7 +274,19 @@ export class InstallHandler {
         const install = this._activeInstalls.get(requestId);
         if (!install)
             return;
-        // Try to abort the AI generation
+        // If this is an ICP flow, abort via AbortController
+        if (install.icpAbort) {
+            install.icpAbort.abort();
+            this._send({
+                type: 'install_result',
+                requestId,
+                status: 'cancelled',
+                code: INSTALL_ERROR_CODES.CANCELLED,
+            }).catch(() => { });
+            this._activeInstalls.delete(requestId);
+            return;
+        }
+        // Chat-based flow: try to abort the AI generation
         try {
             await this._wsClient.request('chat.abort', {
                 sessionKey: this._sessionKey,
@@ -240,12 +302,246 @@ export class InstallHandler {
     }
     /** Disconnect and clean up all active installs. */
     cleanup() {
-        for (const [requestId] of this._activeInstalls) {
+        for (const [requestId, install] of this._activeInstalls) {
+            // Abort any active ICP workspace flows
+            if (install.icpAbort) {
+                install.icpAbort.abort();
+            }
             this._cleanupInstall(requestId);
         }
         this._activeInstalls.clear();
         this._runToRequest.clear();
     }
+    // ── Private: ICP Workspace Flow ─────────────────────────────────
+    /**
+     * Handle an install request through the ICP workspace orchestrator.
+     * On timeout, falls back to the chat-based flow.
+     */
+    async _handleViaIcp(requestId, action, payload, signal) {
+        // Build ICP request from install payload
+        const icpRequest = this._buildIcpRequest(action, payload);
+        if (!icpRequest) {
+            // Can't build ICP request — fall back to chat
+            await this._handleViaChatFallback(requestId, payload);
+            return;
+        }
+        // Map ICP progress to InstallStatus
+        const onProgress = (progress) => {
+            const phaseMap = {
+                writing_task: 'icp_writing_task',
+                waiting_output: 'icp_waiting_output',
+                validating: 'icp_validating',
+                writing_review: 'icp_reviewing',
+                waiting_revision: 'icp_reviewing',
+                fallback: 'icp_fallback',
+                delivering: 'icp_delivering',
+            };
+            const installPhase = phaseMap[progress.phase] ?? 'ai_processing';
+            const message = progress.message ?? this._icpPhaseMessage(progress);
+            this._sendStatus(requestId, installPhase, message).catch(() => { });
+        };
+        // Notify OpenClaw about new tasks/reviews via chat
+        const notifyAI = async (taskId, content, isReview) => {
+            try {
+                const message = isReview
+                    ? `Review feedback written for task ${taskId}. Read the review file and fix the issues, then rewrite output/package.claw.json.`
+                    : `New task available: ${taskId}. Read the task file at claw-apps/${taskId}/task.md and follow the instructions.`;
+                const response = await this._wsClient.request('chat.send', {
+                    sessionKey: this._sessionKey,
+                    message,
+                    idempotencyKey: crypto.randomUUID(),
+                }, this._rpcTimeoutMs);
+                // Register the runId so ChatHandler ignores events for this notification run
+                const notifyRunId = response.payload?.runId;
+                if (notifyRunId) {
+                    this._chatHandler.registerExternalRun(notifyRunId);
+                    // Auto-unregister after timeout — these are fire-and-forget notifications
+                    setTimeout(() => {
+                        this._chatHandler.unregisterExternalRun(notifyRunId);
+                    }, this._timeoutMs).unref?.();
+                }
+            }
+            catch {
+                // Notification failure is non-fatal — OpenClaw may still pick it up
+            }
+        };
+        // Execute ICP flow
+        const result = await this._icpOrchestrator.execute(icpRequest, {
+            onProgress,
+            notifyAI,
+            signal,
+        });
+        // Guard: if aborted while awaiting ICP, don't send duplicate result
+        if (!this._activeInstalls.has(requestId))
+            return;
+        // Handle result
+        switch (result.status) {
+            case 'success': {
+                const pkg = result.output.package;
+                this._send({
+                    type: 'install_result',
+                    requestId,
+                    status: 'success',
+                    app: {
+                        manifest: pkg.manifest,
+                        html: pkg.html ?? '',
+                    },
+                }).catch(() => { });
+                this._activeInstalls.delete(requestId);
+                break;
+            }
+            case 'timeout': {
+                // ICP timed out — remove ICP tracking, fall back to chat-based
+                this._activeInstalls.delete(requestId);
+                console.warn(`[InstallHandler] ICP timeout for ${requestId}, falling back to chat`);
+                await this._handleViaChatFallback(requestId, payload);
+                break;
+            }
+            case 'failed': {
+                this._send({
+                    type: 'install_result',
+                    requestId,
+                    status: 'failed',
+                    error: result.error,
+                    code: INSTALL_ERROR_CODES.ICP_FAILED,
+                }).catch(() => { });
+                this._activeInstalls.delete(requestId);
+                break;
+            }
+            default: {
+                // Unknown status — send failure
+                this._send({
+                    type: 'install_result',
+                    requestId,
+                    status: 'failed',
+                    error: `Unexpected ICP result status: ${result.status}`,
+                    code: INSTALL_ERROR_CODES.ICP_FAILED,
+                }).catch(() => { });
+                this._activeInstalls.delete(requestId);
+                break;
+            }
+        }
+    }
+    /**
+     * Build an IcpRequest from an InstallRequest payload.
+     * Returns null if the payload can't be mapped to an ICP request.
+     */
+    _buildIcpRequest(action, payload) {
+        if ((action === 'install_with_config' || action === 'complete_template') && payload.package) {
+            const pkg = payload.package;
+            const installAction = resolveInstallAction(pkg);
+            if (!installAction.valid)
+                return null;
+            return { type: 'adapt', pkg, installAction };
+        }
+        if (action === 'generate_fresh' && payload.package) {
+            const pkg = payload.package;
+            // Prefer Desktop-provided userRequest; fall back to app name
+            const userRequest = payload.userRequest
+                ?? (typeof pkg.manifest?.name === 'string'
+                    ? `Create app: ${pkg.manifest.name}`
+                    : `Create app: ${pkg.manifest?.name?.en ?? 'New App'}`);
+            return {
+                type: 'create',
+                userRequest,
+                manifest: pkg.manifest,
+            };
+        }
+        if (action === 'adapt' && payload.html && payload.manifest) {
+            const manifest = payload.manifest;
+            const pkg = {
+                manifest,
+                html: payload.html,
+                prompt: { seed: { goal: `Adapt ${manifest.id ?? 'app'}` } },
+            };
+            const installAction = resolveInstallAction(pkg);
+            if (!installAction.valid)
+                return null;
+            return { type: 'adapt', pkg, installAction };
+        }
+        return null;
+    }
+    /**
+     * Fall back to the existing chat-based flow.
+     * Called when ICP times out or can't handle the request.
+     */
+    async _handleViaChatFallback(requestId, payload) {
+        const action = payload.action ?? 'install';
+        // Create active install tracker (same as the normal chat flow)
+        const install = {
+            requestId,
+            action,
+            runId: null,
+            parser: new StreamingMarkerParser(),
+            startedAt: Date.now(),
+            timeoutTimer: null,
+            lastKnownLength: 0,
+            legacy: false,
+            lastStatusAt: 0,
+            streamMarkers: [],
+            hasConfirmedPlan: false,
+            icpAbort: null,
+        };
+        this._activeInstalls.set(requestId, install);
+        const promptPayload = this._buildPromptPayload(payload);
+        const prompt = buildAppRequestPrompt(promptPayload, this._workspaceSynced);
+        await this._sendStatus(requestId, 'sending', 'Falling back to chat-based flow...');
+        try {
+            const response = await this._wsClient.request('chat.send', {
+                sessionKey: this._sessionKey,
+                message: prompt,
+                idempotencyKey: crypto.randomUUID(),
+            }, this._rpcTimeoutMs);
+            if (!response.ok) {
+                this._completeInstall(requestId, {
+                    status: 'failed',
+                    error: response.error?.message || 'chat.send failed',
+                    code: INSTALL_ERROR_CODES.SEND_FAILED,
+                });
+                return;
+            }
+            const runId = response.payload?.runId;
+            if (!runId) {
+                this._completeInstall(requestId, {
+                    status: 'failed',
+                    error: 'No runId returned from chat.send',
+                    code: INSTALL_ERROR_CODES.SEND_FAILED,
+                });
+                return;
+            }
+            install.runId = runId;
+            this._runToRequest.set(runId, requestId);
+            this._chatHandler.registerExternalRun(runId);
+            install.timeoutTimer = setTimeout(() => {
+                this._handleTimeout(requestId);
+            }, this._timeoutMs);
+            if (install.timeoutTimer.unref)
+                install.timeoutTimer.unref();
+            await this._sendStatus(requestId, 'ai_processing', 'Waiting for AI response...');
+        }
+        catch (err) {
+            this._completeInstall(requestId, {
+                status: 'failed',
+                error: err.message || 'Unknown error',
+                code: INSTALL_ERROR_CODES.SEND_FAILED,
+            });
+        }
+    }
+    /**
+     * Generate human-readable message for ICP progress phases.
+     */
+    _icpPhaseMessage(progress) {
+        switch (progress.phase) {
+            case 'writing_task': return 'Preparing task for AI...';
+            case 'waiting_output': return 'Waiting for AI to complete task...';
+            case 'validating': return `Validating output (round ${progress.round ?? 1})...`;
+            case 'writing_review': return `Quality check failed, requesting revision (round ${progress.round}/${progress.maxRounds})...`;
+            case 'waiting_revision': return `Waiting for AI revision (round ${progress.round}/${progress.maxRounds})...`;
+            case 'fallback': return 'Applying auto-fix (degraded delivery)...';
+            case 'delivering': return 'Quality check passed, delivering...';
+            default: return 'Processing...';
+        }
+    }
     // ── Private: Event Handling ────────────────────────────────────
     /**
      * Handle a streaming chat event for an install run.
@@ -631,3 +927,15 @@ export class InstallHandler {
         }
     }
 }
+/** Actions that should be routed through ICP workspace flow. */
+Object.defineProperty(InstallHandler, "ICP_ACTIONS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Set([
+        'install_with_config',
+        'complete_template',
+        'generate_fresh',
+        'adapt',
+    ])
+});

package/dist/install/types.d.ts

@@ -33,6 +33,8 @@ export interface InstallRequest {
     };
     /** Confirmed preview plan (for action='install' following a preview). */
     confirmedPlan?: InstallPreviewData;
+    /** User's original request text (for action='generate_fresh'). */
+    userRequest?: string;
     /** Target app ID (for action='adapt'). */
     appId?: string;
     /** App manifest (for action='adapt'). */
@@ -120,7 +122,7 @@ export interface InstallAck {
     reason?: string;
 }
 /** Install processing phases. */
-export type InstallPhase = 'sending' | 'ai_processing' | 'parsing' | 'validating' | 'previewing' | 'awaiting_confirm' | 'executing';
+export type InstallPhase = 'sending' | 'ai_processing' | 'parsing' | 'validating' | 'previewing' | 'awaiting_confirm' | 'executing' | 'icp_writing_task' | 'icp_waiting_output' | 'icp_validating' | 'icp_reviewing' | 'icp_fallback' | 'icp_delivering';
 /**
  * Progress update during install processing.
  */
@@ -192,6 +194,10 @@ export declare const INSTALL_ERROR_CODES: {
     readonly AI_ERROR: "INSTALL_AI_ERROR";
     /** V2: AI response didn't contain preview data. */
     readonly NO_PREVIEW_DATA: "INSTALL_NO_PREVIEW_DATA";
+    /** V3/ICP: Workspace output timed out, falling back to chat-based. */
+    readonly ICP_TIMEOUT: "INSTALL_ICP_TIMEOUT";
+    /** V3/ICP: ICP orchestrator failed. */
+    readonly ICP_FAILED: "INSTALL_ICP_FAILED";
 };
 /** All install-related messages from Desktop to Agent. */
 export type InstallIncoming = InstallRequest | InstallAbort;

package/dist/install/types.js

@@ -33,4 +33,8 @@ export const INSTALL_ERROR_CODES = {
     AI_ERROR: 'INSTALL_AI_ERROR',
     /** V2: AI response didn't contain preview data. */
     NO_PREVIEW_DATA: 'INSTALL_NO_PREVIEW_DATA',
+    /** V3/ICP: Workspace output timed out, falling back to chat-based. */
+    ICP_TIMEOUT: 'INSTALL_ICP_TIMEOUT',
+    /** V3/ICP: ICP orchestrator failed. */
+    ICP_FAILED: 'INSTALL_ICP_FAILED',
 };

package/dist/service/launchd.d.ts

@@ -10,6 +10,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class LaunchdService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/launchd.js

@@ -105,6 +105,14 @@ ${args.map(a => `    <string>${escapeXml(a)}</string>`).join('\n')}
         await fs.writeFile(PLIST_PATH, plist, 'utf-8');
         await bootstrapService();
     }
+    async restart() {
+        const st = await this.status();
+        if (!st.installed) {
+            throw new Error('Service not installed. Run setup first.');
+        }
+        await bootoutService();
+        await bootstrapService();
+    }
     async uninstall() {
         await bootoutService();
         try {

package/dist/service/platform.d.ts

@@ -10,6 +10,7 @@ export interface ServiceInstallOptions {
 export interface ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
     uninstall(): Promise<void>;
+    restart(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }
 export interface ServiceStatus {

package/dist/service/systemd.d.ts

@@ -11,6 +11,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class SystemdService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/systemd.js

@@ -171,6 +171,13 @@ WantedBy=default.target
             console.log(`  ⚠  loginctl enable-linger failed (may require sudo). Service will start on login.`);
         }
     }
+    async restart() {
+        const userSessionOk = await isUserSessionAvailable();
+        if (!userSessionOk) {
+            throw new Error('systemd user session not available. Try: sudo loginctl enable-linger $(whoami)');
+        }
+        await execFileAsync('systemctl', ['--user', 'restart', UNIT_NAME]);
+    }
     async uninstall() {
         try {
             await execFileAsync('systemctl', ['--user', 'disable', '--now', UNIT_NAME]);

package/dist/service/windows.d.ts

@@ -7,6 +7,7 @@
 import type { ServiceManager, ServiceStatus, ServiceInstallOptions } from './platform.js';
 export declare class WindowsService implements ServiceManager {
     install(relayServer: string, options?: ServiceInstallOptions): Promise<void>;
+    restart(): Promise<void>;
     uninstall(): Promise<void>;
     status(): Promise<ServiceStatus>;
 }

package/dist/service/windows.js

@@ -128,6 +128,13 @@ export class WindowsService {
         }
         catch { /* may fail if already running */ }
     }
+    async restart() {
+        try {
+            await execFileAsync('schtasks', ['/End', '/TN', TASK_NAME]);
+        }
+        catch { /* not running */ }
+        await execFileAsync('schtasks', ['/Run', '/TN', TASK_NAME]);
+    }
     async uninstall() {
         try {
             await execFileAsync('schtasks', ['/End', '/TN', TASK_NAME]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echoclaw-relay-agent",
-  "version": "0.22.4",
+  "version": "0.22.6",
   "description": "EchoClaw Relay Connection — E2E encrypted relay transport, pairing, and session management",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,6 +22,8 @@
     "dev": "tsx src/cli.ts"
   },
   "dependencies": {
+    "@echoclaw/claw-engine": "workspace:*",
+    "@echoclaw/icp-orchestrator": "workspace:*",
     "echoclaw-crypto": "0.3.1",
     "ws": "^8.18.0"
   },