handsoff 0.1.3 → 0.1.6-beta.0

package/dist/cli/index.js

@@ -122,12 +122,12 @@ function resetCredentials() {
 }
 
 // src/cli/attach.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3, dirname as dirname2 } from "path";
 
 // src/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import TOML from "@iarna/toml";
@@ -151,8 +151,7 @@ var DEFAULT_CONFIG = {
       enabled: false,
       app_id: "",
       app_secret: "",
-      allowed_users: [],
-      notify_types: []
+      allowed_users: []
     },
     permission: {
       timeout_ms: 3e5,
@@ -199,23 +198,20 @@ function mergeWithDefaults(raw) {
     channel: {
       logger: {
         ...DEFAULT_CONFIG.channel.logger,
-        ...raw.channel?.logger || {},
-        notify_types: raw.channel?.logger?.notify_types
+        ...raw.channel?.logger || {}
       },
       telegram: {
         ...DEFAULT_CONFIG.channel.telegram,
         ...raw.channel?.telegram || {},
         allowed_users: (raw.channel?.telegram?.allowed_users || []).map(String),
-        bot_token: process.env.HANDSOFF_TELEGRAM_BOT_TOKEN || raw.channel?.telegram?.bot_token || "",
-        notify_types: raw.channel?.telegram?.notify_types
+        bot_token: process.env.HANDSOFF_TELEGRAM_BOT_TOKEN || raw.channel?.telegram?.bot_token || ""
       },
       feishu: {
         ...DEFAULT_CONFIG.channel.feishu,
         ...raw.channel?.feishu || {},
         allowed_users: raw.channel?.feishu?.allowed_users || [],
         app_id: process.env.HANDSOFF_FEISHU_APP_ID || raw.channel?.feishu?.app_id || "",
-        app_secret: process.env.HANDSOFF_FEISHU_APP_SECRET || raw.channel?.feishu?.app_secret || "",
-        notify_types: raw.channel?.feishu?.notify_types
+        app_secret: process.env.HANDSOFF_FEISHU_APP_SECRET || raw.channel?.feishu?.app_secret || ""
       },
       permission: {
         ...DEFAULT_CONFIG.channel.permission,
@@ -235,8 +231,7 @@ function mergeWithDefaults(raw) {
         enabled: raw.channel?.app?.enabled === true,
         channel_id: String(raw.channel?.app?.channel_id || ""),
         auth_token: String(raw.channel?.app?.auth_token || ""),
-        heartbeat_interval_ms: raw.channel?.app?.heartbeat_interval_ms ? parseInt(String(raw.channel?.app?.heartbeat_interval_ms), 10) : void 0,
-        notify_types: Array.isArray(raw.channel?.app?.notify_types) ? raw.channel.app.notify_types.map(String) : void 0
+        heartbeat_interval_ms: raw.channel?.app?.heartbeat_interval_ms ? parseInt(String(raw.channel?.app?.heartbeat_interval_ms), 10) : void 0
       }
     },
     agent: {
@@ -256,9 +251,44 @@ function mergeWithDefaults(raw) {
     bindings: {
       ...DEFAULT_CONFIG.bindings,
       ...raw.bindings || {}
-    }
+    },
+    workspaces: raw.workspaces || {}
   };
 }
+function migrateLegacyBindings(config) {
+  if (!config.bindings) return config;
+  const entries = Object.entries(config.bindings);
+  const isLegacy = entries.some(
+    ([k, v]) => !k.includes(":") && String(v).includes(":")
+  );
+  if (!isLegacy) return config;
+  const newConfig = {
+    ...config,
+    workspaces: { ...config.workspaces || {} },
+    bindings: {}
+  };
+  for (const [agentType, channelId] of entries) {
+    const wsId = agentType;
+    newConfig.workspaces[wsId] = {
+      name: agentType,
+      description: "Migrated from legacy binding"
+    };
+    if (channelId) {
+      newConfig.bindings[channelId] = wsId;
+    }
+  }
+  try {
+    const configPath = getConfigPath();
+    const raw = TOML.parse(readFileSync2(configPath, "utf-8"));
+    raw.workspaces = newConfig.workspaces;
+    raw.bindings = newConfig.bindings;
+    writeFileSync2(configPath, TOML.stringify(raw), "utf-8");
+    console.log("[Config] Migrated legacy bindings to workspace format");
+  } catch (err) {
+    console.warn("[Config] Failed to persist migrated config:", err);
+  }
+  return newConfig;
+}
 function loadConfig() {
   const configPath = getConfigPath();
   if (!existsSync2(configPath)) {
@@ -267,7 +297,8 @@ function loadConfig() {
   try {
     const content = readFileSync2(configPath, "utf-8");
     const raw = TOML.parse(content);
-    return mergeWithDefaults(raw);
+    const config = mergeWithDefaults(raw);
+    return migrateLegacyBindings(config);
   } catch (error) {
     console.error(`Failed to load config from ${configPath}:`, error);
     return DEFAULT_CONFIG;
@@ -285,63 +316,6 @@ var en_default = {
       channel: "[ Channel Configuration ]",
       complete: "[ Setup Complete ]"
     },
-    cli: {
-      runAgain: "Run init again when Claude Code is installed.",
-      detected: "Claude Code detected.",
-      hooksInstalled: "Hooks already installed.",
-      hooksNotInstalled: "Hooks not installed.",
-      hooksTokenMismatch: "Hooks have outdated token - reconfiguration required.",
-      actionQuestion: "Select action:",
-      injectAction: "Inject hooks configuration",
-      updateAction: "Update hooks configuration",
-      backAction: "Back",
-      hookCheckbox: "Select hooks:",
-      noHooksSelected: "No hooks selected, skipping injection.",
-      injecting: "Injecting hooks...",
-      injected: "Hooks injected",
-      failed: "Failed: {{error}}",
-      remoteModeSkipHooks: "Remote mode does not require hooks; skipping injection.",
-      cleaningHooks: "Cleaning up hooks from previous mode...",
-      hooksCleaned: "Hooks cleaned",
-      cleanupWarning: "Hook cleanup warning: {{error}}"
-    },
-    channel: {
-      configuring: "Configuring {{channel}}",
-      telegram: {
-        botToken: "Telegram bot token:",
-        allowedUsers: "Allowed Telegram user IDs (comma-separated):",
-        testing: "Testing Telegram connection...",
-        connected: "Connected to Telegram",
-        sendingTest: "Sending test message...",
-        testSent: "Test message sent",
-        testContent: "Handsoff test message",
-        testWarning: "Could not send test message (user may not have messaged bot yet)",
-        apiError: "API error: {{status}}",
-        connFailed: "Connection failed: {{error}}"
-      },
-      feishu: {
-        appId: "Feishu App ID:",
-        appSecret: "Feishu App Secret:",
-        allowedUsers: "Allowed User IDs (comma-separated, e.g., ou_xxx,oc_xxx):",
-        required: "app_id and app_secret are required. Skipping."
-      }
-    },
-    codex: {
-      enable: "Enable Codex agent integration?",
-      command: "Codex app-server command:",
-      workDir: "Default Codex working directory (optional):",
-      model: "Default Codex model (optional):",
-      approvalPolicy: "Default Codex approval policy (optional):",
-      detected: "Codex CLI detected.",
-      notDetected: "Codex CLI not found in PATH.",
-      enabled: "Codex integration enabled.",
-      disabled: "Codex integration disabled."
-    },
-    notify: {
-      title: "Notification types for {{channel}}",
-      checkbox: "Notification types:",
-      saved: "Notification types saved for {{channel}}"
-    },
     menu: {
       select: "Select:",
       next: "--- Next ---",
@@ -351,81 +325,137 @@ var en_default = {
       backToMenu: "Back to menu",
       restartQuestion: "Restart Gateway now?"
     },
-    final: {
-      noItems: "No items configured.",
-      itemOk: "{{item}}: OK",
-      running: "Gateway is running",
-      runningChanges: "Gateway is running with pending changes",
-      configModified: "Configuration was modified. Restart required to apply changes.",
-      runningReady: "Gateway is already running and ready.",
-      notRunning: "Gateway is not running",
-      configModifiedStart: "Configuration was modified. Starting Gateway with new configuration.",
-      restarting: "Restarting...",
-      restarted: "Gateway restarted with new configuration",
-      starting: "Starting...",
-      started: "Gateway started",
-      startFailed: "Failed: {{error}}",
-      restartTip: "Run `handsoff gateway start` to restart.",
-      startTip: "Run `handsoff gateway start` to start.",
-      done: "Done."
-    }
-  },
-  gateway: {
-    stopping: "Stopping daemon...",
-    startedOnPort: "Gateway started on port {{port}}",
-    stopped: "Daemon stopped",
-    notRunning: "Daemon is not running",
-    restartedOnPort: "Gateway restarted on port {{port}}",
-    startFailed: "Failed to start Gateway",
-    stopFailed: "Failed to stop Gateway",
-    restartFailed: "Failed to restart Gateway",
-    error: "  Error: {{error}}",
-    checkLogs: "Check logs at: {{path}}",
-    status: {
-      title: "Gateway Status:",
-      running: "Running: {{value}}",
-      sessions: "Sessions: {{count}}",
-      clients: "Connected clients: {{count}}",
-      activeSessions: "Active sessions:",
-      notResponding: "Gateway is not responding",
-      notRunning: "Gateway is not running"
+    step: {
+      cli: {
+        runAgain: "Run init again when Claude Code is installed.",
+        detected: "Claude Code detected.",
+        hooksInstalled: "Hooks already installed.",
+        hooksNotInstalled: "Hooks not installed.",
+        hooksTokenMismatch: "Hooks have outdated token - reconfiguration required.",
+        actionQuestion: "Select action:",
+        injectAction: "Inject hooks configuration",
+        updateAction: "Update hooks configuration",
+        backAction: "Back",
+        hookCheckbox: "Select hooks:",
+        noHooksSelected: "No hooks selected, skipping injection.",
+        injecting: "Injecting hooks...",
+        injected: "Hooks injected",
+        failed: "Failed: {{error}}",
+        remoteModeSkipHooks: "Remote mode does not require hooks; skipping injection.",
+        cleaningHooks: "Cleaning up hooks from previous mode...",
+        hooksCleaned: "Hooks cleaned",
+        cleanupWarning: "Hook cleanup warning: {{error}}"
+      },
+      channel: {
+        configuring: "Configuring {{channel}}",
+        telegram: {
+          botToken: "Telegram bot token:",
+          allowedUsers: "Allowed Telegram user IDs (comma-separated):",
+          testing: "Testing Telegram connection...",
+          connected: "Connected to Telegram",
+          sendingTest: "Sending test message...",
+          testSent: "Test message sent",
+          testContent: "Handsoff test message",
+          testWarning: "Could not send test message (user may not have messaged bot yet)",
+          apiError: "API error: {{status}}",
+          connFailed: "Connection failed: {{error}}"
+        },
+        feishu: {
+          appId: "Feishu App ID:",
+          appSecret: "Feishu App Secret:",
+          allowedUsers: "Allowed User IDs (comma-separated, e.g., ou_xxx,oc_xxx):",
+          required: "app_id and app_secret are required. Skipping."
+        },
+        subscribedEvents: "Notification types:"
+      },
+      codex: {
+        enable: "Enable Codex agent integration?",
+        command: "Codex app-server command:",
+        workDir: "Default Codex working directory (optional):",
+        model: "Default Codex model (optional):",
+        approvalPolicy: "Default Codex approval policy (optional):",
+        detected: "Codex CLI detected.",
+        notDetected: "Codex CLI not found in PATH.",
+        enabled: "Codex integration enabled.",
+        disabled: "Codex integration disabled."
+      },
+      final: {
+        noItems: "No items configured.",
+        itemOk: "{{item}}: OK",
+        running: "Gateway is running",
+        runningChanges: "Gateway is running with pending changes",
+        configModified: "Configuration was modified. Restart required to apply changes.",
+        runningReady: "Gateway is already running and ready.",
+        notRunning: "Gateway is not running",
+        configModifiedStart: "Configuration was modified. Starting Gateway with new configuration.",
+        restarting: "Restarting...",
+        restarted: "Gateway restarted with new configuration",
+        starting: "Starting...",
+        started: "Gateway started",
+        startFailed: "Failed: {{error}}",
+        restartTip: "Run `handsoff gateway start` to restart.",
+        startTip: "Run `handsoff gateway start` to start.",
+        done: "Done."
+      }
     }
   },
-  daemon: {
-    alreadyRunning: "Daemon is already running",
-    startedOnPort: "Daemon started on port {{port}}",
-    startFailed: "Daemon failed to start. Check logs for details.",
-    checkLogs: "Check logs at: {{path}}",
-    portInUse: "Warning: Port {{port}} still in use after {{ms}}ms",
-    startError: "Failed to start daemon: {{error}}",
-    lackingToken: "Daemon is running but PID file lacks token, restarting...",
-    scriptNotFound: "Daemon script not found: {{path}}"
-  },
-  status: {
-    title: "=== Handsoff Status ===",
-    daemon: {
-      running: "Daemon: \u2713 Running",
-      notRunning: "Daemon: \u2717 Not running"
+  cli: {
+    gateway: {
+      stopping: "Stopping daemon...",
+      startedOnPort: "Gateway started on port {{port}}",
+      stopped: "Daemon stopped",
+      notRunning: "Daemon is not running",
+      restartedOnPort: "Gateway restarted on port {{port}}",
+      startFailed: "Failed to start Gateway",
+      stopFailed: "Failed to stop Gateway",
+      restartFailed: "Failed to restart Gateway",
+      error: "  Error: {{error}}",
+      checkLogs: "Check logs at: {{path}}",
+      status: {
+        title: "Gateway Status:",
+        running: "Running: {{value}}",
+        sessions: "Sessions: {{count}}",
+        clients: "Connected clients: {{count}}",
+        activeSessions: "Active sessions:",
+        notResponding: "Gateway is not responding",
+        notRunning: "Gateway is not running"
+      }
     },
-    port: "Port: {{port}}",
-    logLevel: "Log Level: {{level}}",
-    channels: "Channels:",
-    telegram: {
-      enabled: "Telegram: \u2713 Enabled",
-      disabled: "Telegram: \u2717 Disabled"
+    daemon: {
+      alreadyRunning: "Daemon is already running",
+      startedOnPort: "Daemon started on port {{port}}",
+      startFailed: "Daemon failed to start. Check logs for details.",
+      checkLogs: "Check logs at: {{path}}",
+      portInUse: "Warning: Port {{port}} still in use after {{ms}}ms",
+      startError: "Failed to start daemon: {{error}}",
+      lackingToken: "Daemon is running but PID file lacks token, restarting...",
+      staleProcess: "Daemon process exists but HTTP server is not responding, restarting...",
+      scriptNotFound: "Daemon script not found: {{path}}"
     },
-    feishu: {
-      enabled: "Feishu: \u2713 Enabled",
-      disabled: "Feishu: \u2717 Disabled"
+    status: {
+      title: "=== Handsoff Status ===",
+      daemon: {
+        running: "Daemon: \u2713 Running",
+        notRunning: "Daemon: \u2717 Not running"
+      },
+      port: "Port: {{port}}",
+      logLevel: "Log Level: {{level}}",
+      channels: "Channels:",
+      telegram: {
+        enabled: "Telegram: \u2713 Enabled",
+        disabled: "Telegram: \u2717 Disabled"
+      },
+      feishu: {
+        enabled: "Feishu: \u2713 Enabled",
+        disabled: "Feishu: \u2717 Disabled"
+      },
+      settingsBackup: "Settings: \u2713 Backup exists",
+      settingsNoBackup: "Settings: \u2717 No backup",
+      paths: "Paths:",
+      pathConfig: "Config: {{path}}",
+      pathLogs: "Logs: {{path}}",
+      pathBackup: "Backup: {{path}}"
     },
-    settingsBackup: "Settings: \u2713 Backup exists",
-    settingsNoBackup: "Settings: \u2717 No backup",
-    paths: "Paths:",
-    pathConfig: "Config: {{path}}",
-    pathLogs: "Logs: {{path}}",
-    pathBackup: "Backup: {{path}}"
-  },
-  cli: {
     init: {
       configExists: "Configuration exists. Continue?",
       cancelled: "Cancelled."
@@ -492,7 +522,72 @@ var en_default = {
       stopping: "\nStopping debug server..."
     }
   },
-  notifications: {
+  commands: {
+    start: {
+      title: "Handsoff",
+      hasWorkspace: "Current workspace: **{{name}}** (`{{id}}`).",
+      noWorkspace: "No workspace is bound to this channel yet.",
+      noWorkspaceWithList: "No workspace is selected for this channel. Available workspaces:",
+      switchPrompt: "Use `/workspace switch <id>` to select one.",
+      howToUse: "How to use it",
+      sendText: "Send plain text to start a session with the default agent (claude).",
+      useAgentPrefix: "Use `/claude <text>` or `/codex <text>` to talk to a specific agent.",
+      createWorkspace: "Use `/workspace create <name>` to create a workspace.",
+      listWorkspaces: "Use `/workspace list` to see available workspaces.",
+      switchWorkspace: "Use `/workspace switch <id>` to switch workspace.",
+      startFresh: "Use `/new` or `/clear` to start fresh in this chat.",
+      inspectSession: "Use `/session` to inspect the current chat session.",
+      seeHelp: "Use `/help` to see system commands."
+    },
+    workspace: {
+      noWorkspaces: "No workspaces yet. Use `/workspace create <name>` to create one.",
+      listTitle: "Workspaces",
+      listItem: "- `{{id}}` \u2014 {{name}} ({{cwd}})",
+      noWorkspaceBound: "No workspace is bound to this channel. Use `/workspace switch <id>`.",
+      currentTitle: "Current Workspace",
+      currentId: "ID: `{{id}}`",
+      currentName: "Name: {{name}}",
+      currentCwd: "CWD: `{{cwd}}`",
+      currentDescription: "Description: {{description}}",
+      switchUsage: "Usage: /workspace switch <id>",
+      notFound: "Workspace `{{id}}` not found.",
+      availableWorkspaces: "Available workspaces:",
+      switched: "Switched to workspace '{{name}}' ({{id}}).",
+      createUsage: "Usage: /workspace create <name> [--cwd <path>] [--id <id>] [--desc <text>]",
+      alreadyExists: "Workspace `{{id}}` already exists.",
+      created: "Created workspace '{{name}}' (`{{id}}`) at {{cwd}}",
+      createdAndBound: "Created workspace '{{name}}' (`{{id}}`) at {{cwd}} and auto-bound to this channel. You can start sending messages now.",
+      deleteUsage: "Usage: /workspace delete <id>",
+      deleted: "Deleted workspace '{{name}}' (`{{id}}`).",
+      infoNoWorkspaceBound: "No workspace bound to this channel. Use `/workspace switch <id>` or `/workspace info <id>`.",
+      infoTitle: "Workspace: {{name}}",
+      infoCreated: "Created: {{createdAt}}",
+      infoPermissionMode: "Permission Mode: {{mode}}",
+      unbindNoWorkspace: "No workspace is bound to this channel.",
+      unbound: "Unbound workspace '{{name}}' from this channel.",
+      rootNoWorkspace: "No workspace bound. Use `/workspace list` to see available workspaces, or `/workspace switch <id>` to bind one.",
+      rootCurrent: "Current workspace: '{{name}}' (`{{id}}`). Use /workspace <subcommand> for actions."
+    }
+  },
+  notify: {
+    titles: {
+      sessionStart: "\u{1F680} Session Started",
+      sessionEnd: "\u{1F44B} Session Ended",
+      turnStarted: "\u{1F504} Turn Started",
+      turnFinished: "\u2705 Task Completed",
+      turnThinking: "\u{1F4AD} Thinking...",
+      toolPost: "\u{1F527} Tool Call",
+      toolExecuted: "\u2705 Tool Executed",
+      toolFailure: "\u274C Tool Failed",
+      permissionRequest: "\u{1F510} Permission Request",
+      permissionResponse: "\u{1F4CB} Permission Response",
+      questionRequest: "\u2753 Question",
+      questionResponse: "\u{1F4CB} Question Response",
+      systemEvent: "\u{1F4CB} System Event",
+      agentMessage: "\u{1F916} Agent Message",
+      error: "\u26A0\uFE0F Error",
+      fallback: "\u{1F4CB} Notification"
+    },
     permission: {
       title: "\u{1F510} Permission Request",
       session: "Session: {{sessionId}}",
@@ -521,23 +616,62 @@ var en_default = {
     },
     unauthorized: "You are not authorized to use this bot.",
     received: "Message received.",
-    processingError: "Error processing message."
+    processingError: "Error processing message.",
+    fallback: {
+      permission: "Reply /approve or /deny"
+    }
   },
-  eventTitles: {
-    sessionStart: "\u{1F680} Session Started",
-    sessionEnd: "\u{1F44B} Session Ended",
-    turnFinished: "\u2705 Task Completed",
-    turnThinking: "\u{1F4AD} Thinking...",
-    toolPost: "\u{1F527} Tool Call",
-    toolExecuted: "\u2705 Tool Executed",
-    toolFailure: "\u274C Tool Failed",
-    permissionRequest: "\u{1F510} Permission Request",
-    permissionResponse: "\u{1F4CB} Permission Response",
-    questionRequest: "\u2753 Question",
-    questionResponse: "\u{1F4CB} Question Response",
-    agentMessage: "\u{1F916} Agent Message",
-    error: "\u26A0\uFE0F Error",
-    fallback: "\u{1F4CB} Notification"
+  agent: {
+    claude: {
+      command: {
+        model: {
+          description: "Set default model for Claude",
+          usage: "Usage: /model <model-name>",
+          usageHint: "Usage: /model <model-name>",
+          success: "Model set to {{model}}"
+        },
+        permission: {
+          description: "Set permission mode for Claude",
+          usage: "Usage: /permission <mode>",
+          invalidMode: "Invalid mode: {{mode}}. Valid modes: {{modes}}",
+          success: "Permission mode set to {{mode}}"
+        }
+      },
+      concurrentTurn: "Claude is still processing the previous message. Please wait.",
+      sessionEndedUnexpectedly: "Claude session ended unexpectedly."
+    },
+    codex: {
+      clientTitle: "Handsoff Codex Client",
+      concurrentTurn: "Codex is still processing the previous message. Please wait."
+    }
+  },
+  channel: {
+    fallback: {
+      replyByNumber: "Please reply with the number:"
+    },
+    feishu: {
+      card: {
+        taskCompleted: "\u2705 Task Completed",
+        noOutput: "No output",
+        permissionRequired: "Permission Required",
+        questionTitle: "Question",
+        errorTitle: "\u274C Error",
+        submit: "Submit"
+      },
+      confirm: {
+        denyTitle: "Confirm Deny",
+        denyText: "Are you sure you want to deny?",
+        alwaysAllowTitle: "Confirm Always Allow",
+        alwaysAllowText: "Are you sure you want to always allow?"
+      },
+      toast: {
+        processed: "Processed"
+      }
+    },
+    telegram: {
+      invalidRequest: "Invalid request",
+      unauthorized: "Unauthorized"
+    }
   }
 };
 
@@ -559,12 +693,12 @@ function getSettingsPath() {
 function backupSettings(settingsPath) {
   const backupPath = settingsPath + ".handsoff-backup";
   if (existsSync3(settingsPath)) {
-    writeFileSync2(backupPath, readFileSync3(settingsPath, "utf-8"));
+    writeFileSync3(backupPath, readFileSync3(settingsPath, "utf-8"));
   }
 }
 function writeSettings(settingsPath, settings) {
   mkdirSync2(dirname2(settingsPath), { recursive: true });
-  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync3(settingsPath, JSON.stringify(settings, null, 2));
 }
 function getGatewayBaseUrl(port) {
   return `http://localhost:${port}`;
@@ -662,7 +796,7 @@ function createInitialState(hasExistingConfig) {
 }
 
 // src/cli/wizard/applicator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
 import TOML2 from "@iarna/toml";
@@ -709,7 +843,7 @@ var ConfigApplicator = class {
     mkdirSync3(configDir, { recursive: true });
     const configPath = join4(configDir, "config.toml");
     const content = TOML2.stringify(finalConfig);
-    writeFileSync3(configPath, content);
+    writeFileSync4(configPath, content);
   }
 };
 
@@ -846,47 +980,61 @@ function detectCodex() {
 
 // src/cli/wizard/prompts.ts
 import { confirm, input, checkbox, select } from "@inquirer/prompts";
+var EVENT_TYPE_CHOICES = [
+  { name: t("notify.titles.sessionStart"), value: "session:start" },
+  { name: t("notify.titles.sessionEnd"), value: "session:end" },
+  { name: t("notify.titles.turnStarted"), value: "turn:started" },
+  { name: t("notify.titles.turnThinking"), value: "turn:thinking" },
+  { name: t("notify.titles.turnFinished"), value: "turn:finished" },
+  { name: t("notify.titles.toolPost"), value: "tool:post" },
+  { name: t("notify.titles.toolExecuted"), value: "tool:executed" },
+  { name: t("notify.titles.toolFailure"), value: "tool:failure" },
+  { name: t("notify.titles.permissionRequest"), value: "permission:request" },
+  { name: t("notify.titles.questionRequest"), value: "question:request" },
+  { name: t("notify.titles.systemEvent"), value: "system:event" },
+  { name: t("notify.titles.error"), value: "error" }
+];
 var prompts = {
   feishuAppId: (current) => input({
-    message: t("wizard.channel.feishu.appId"),
+    message: t("wizard.step.channel.feishu.appId"),
     default: current || ""
   }),
   feishuAppSecret: (current) => input({
-    message: t("wizard.channel.feishu.appSecret"),
+    message: t("wizard.step.channel.feishu.appSecret"),
     default: current || ""
   }),
   feishuAllowedUsers: (current) => input({
-    message: t("wizard.channel.feishu.allowedUsers"),
+    message: t("wizard.step.channel.feishu.allowedUsers"),
     default: current || ""
   }),
   codexEnable: (enabled) => confirm({
-    message: t("wizard.codex.enable"),
+    message: t("wizard.step.codex.enable"),
     default: enabled
   }),
   codexCommand: (current) => input({
-    message: t("wizard.codex.command"),
+    message: t("wizard.step.codex.command"),
     default: current || "codex app-server --listen stdio://"
   }),
   codexWorkDir: (current) => input({
-    message: t("wizard.codex.workDir"),
+    message: t("wizard.step.codex.workDir"),
     default: current || ""
   }),
   codexModel: (current) => input({
-    message: t("wizard.codex.model"),
+    message: t("wizard.step.codex.model"),
     default: current || ""
   }),
   codexApprovalPolicy: (current) => input({
-    message: t("wizard.codex.approvalPolicy"),
+    message: t("wizard.step.codex.approvalPolicy"),
     default: current || ""
   }),
   cliActionSelect: (hooked) => select({
-    message: t("wizard.cli.actionQuestion"),
+    message: t("wizard.step.cli.actionQuestion"),
     choices: hooked ? [
-      { name: t("wizard.cli.updateAction"), value: "update" },
-      { name: t("wizard.cli.backAction"), value: "back" }
+      { name: t("wizard.step.cli.updateAction"), value: "update" },
+      { name: t("wizard.step.cli.backAction"), value: "back" }
     ] : [
-      { name: t("wizard.cli.injectAction"), value: "inject" },
-      { name: t("wizard.cli.backAction"), value: "back" }
+      { name: t("wizard.step.cli.injectAction"), value: "inject" },
+      { name: t("wizard.step.cli.backAction"), value: "back" }
     ]
   }),
   claudeMode: () => select({
@@ -909,7 +1057,7 @@ var prompts = {
     default: defaultValue ?? "acceptEdits"
   }),
   cliHookSelect: (selected) => checkbox({
-    message: t("wizard.cli.hookCheckbox"),
+    message: t("wizard.step.cli.hookCheckbox"),
     choices: [
       { name: "Stop", value: "Stop", checked: selected?.includes("Stop") ?? true },
       { name: "SessionStart", value: "SessionStart", checked: selected?.includes("SessionStart") ?? true },
@@ -924,11 +1072,11 @@ var prompts = {
     ]
   }),
   botToken: (current) => input({
-    message: t("wizard.channel.telegram.botToken"),
+    message: t("wizard.step.channel.telegram.botToken"),
     default: current || ""
   }),
   allowedUsers: (current) => input({
-    message: t("wizard.channel.telegram.allowedUsers"),
+    message: t("wizard.step.channel.telegram.allowedUsers"),
     default: current || ""
   }),
   channelMenuSelect: (channels) => select({
@@ -941,16 +1089,6 @@ var prompts = {
       { name: t("wizard.menu.next"), value: "__next__" }
     ]
   }),
-  notifyTypes: (selected) => checkbox({
-    message: t("wizard.notify.checkbox"),
-    choices: [
-      { name: "permission:request", value: "permission:request", checked: selected?.includes("permission:request") },
-      { name: "question:request", value: "question:request", checked: selected?.includes("question:request") },
-      { name: "turn:finished", value: "turn:finished", checked: selected?.includes("turn:finished") },
-      { name: "session:start", value: "session:start", checked: selected?.includes("session:start") },
-      { name: "error", value: "error", checked: selected?.includes("error") }
-    ]
-  }),
   channelConfigError: () => select({
     message: t("wizard.menu.testFailed"),
     choices: [
@@ -988,11 +1126,18 @@ var prompts = {
   channelSelect: (channels) => select({
     message: "Select a channel to configure:",
     choices: channels.map((c) => ({ name: `${c.name}  ${c.status}`, value: c.value }))
+  }),
+  subscribedEventsSelect: (selected) => checkbox({
+    message: t("wizard.step.channel.subscribedEvents"),
+    choices: EVENT_TYPE_CHOICES.map((choice) => ({
+      ...choice,
+      checked: selected?.includes(choice.value) ?? true
+    }))
   })
 };
 
 // src/cli/wizard/steps/cli.ts
-import { writeFileSync as writeFileSync4, existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync4 } from "fs";
+import { writeFileSync as writeFileSync5, existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname3 } from "path";
 import pc from "picocolors";
 import ora from "ora";
@@ -1009,21 +1154,21 @@ ${STEP} \u2014 Configure Agent
     const detection = state.claudeDetection ?? detectClaude();
     if (!detection.supported) {
       console.log(pc.yellow(`! ${detection.message}`));
-      console.log(pc.gray(`  ${t("wizard.cli.runAgain")}
+      console.log(pc.gray(`  ${t("wizard.step.cli.runAgain")}
 `));
       return { action: "next", next: "cli-menu" };
     }
-    console.log(pc.green(`* ${t("wizard.cli.detected")}`));
+    console.log(pc.green(`* ${t("wizard.step.cli.detected")}`));
     console.log(pc.gray(`  Settings: ${detection.settingsPath}`));
     const port = loadConfig().general.hook_server_port;
     const token = getHookToken();
     console.log(pc.gray(`  Gateway: http://localhost:${port}/hook/${token ? token.substring(0, 8) + "..." : "unknown"}`));
     if (detection.hooked) {
-      console.log(pc.green(`  ${t("wizard.cli.hooksInstalled")}`));
+      console.log(pc.green(`  ${t("wizard.step.cli.hooksInstalled")}`));
     } else if (detection.tokenMismatch) {
-      console.log(pc.red(`  ${t("wizard.cli.hooksTokenMismatch")}`));
+      console.log(pc.red(`  ${t("wizard.step.cli.hooksTokenMismatch")}`));
     } else {
-      console.log(pc.yellow(`  ${t("wizard.cli.hooksNotInstalled")}`));
+      console.log(pc.yellow(`  ${t("wizard.step.cli.hooksNotInstalled")}`));
     }
     console.log("");
     const mode = await prompts.claudeMode();
@@ -1035,29 +1180,29 @@ ${STEP} \u2014 Configure Agent
       }
       const selectedHooks = await prompts.cliHookSelect();
       if (selectedHooks.length === 0) {
-        console.log(pc.yellow(`! ${t("wizard.cli.noHooksSelected")}
+        console.log(pc.yellow(`! ${t("wizard.step.cli.noHooksSelected")}
 `));
         return { action: "next", next: "cli-menu" };
       }
-      const spinner = ora(t("wizard.cli.injecting")).start();
+      const spinner = ora(t("wizard.step.cli.injecting")).start();
       try {
         injectClaudeHooks(detection.settingsPath, selectedHooks);
-        spinner.succeed(t("wizard.cli.injected"));
+        spinner.succeed(t("wizard.step.cli.injected"));
       } catch (err) {
-        spinner.fail(t("wizard.cli.failed", { error: String(err) }));
+        spinner.fail(t("wizard.step.cli.failed", { error: String(err) }));
         state.itemStatus.set("claude", "error");
         state.validationResults.set("claude", { ok: false, message: String(err) });
         return { action: "next", next: "cli-menu" };
       }
     } else {
-      const spinner = ora(t("wizard.cli.cleaningHooks")).start();
+      const spinner = ora(t("wizard.step.cli.cleaningHooks")).start();
       try {
         cleanupClaudeHooks(detection.settingsPath);
-        spinner.succeed(t("wizard.cli.hooksCleaned"));
+        spinner.succeed(t("wizard.step.cli.hooksCleaned"));
       } catch (err) {
-        spinner.warn(t("wizard.cli.cleanupWarning", { error: String(err) }));
+        spinner.warn(t("wizard.step.cli.cleanupWarning", { error: String(err) }));
       }
-      console.log(pc.yellow(`! ${t("wizard.cli.remoteModeSkipHooks")}`));
+      console.log(pc.yellow(`! ${t("wizard.step.cli.remoteModeSkipHooks")}`));
       try {
         execSync3("claude --version", { stdio: "ignore" });
       } catch {
@@ -1084,14 +1229,14 @@ ${STEP} \u2014 Configure Agent
     const config = loadConfig();
     const current = config.agent.codex;
     if (!detection.installed) {
-      console.log(pc.yellow(`! ${t("wizard.codex.notDetected")}`));
+      console.log(pc.yellow(`! ${t("wizard.step.codex.notDetected")}`));
       console.log(pc.gray(`  ${detection.message}
 `));
       state.itemStatus.set("codex", "not-found");
       state.validationResults.set("codex", { ok: false, message: detection.message });
       return { action: "next", next: "cli-menu" };
     }
-    console.log(pc.green(`* ${t("wizard.codex.detected")}`));
+    console.log(pc.green(`* ${t("wizard.step.codex.detected")}`));
     console.log(pc.gray(`  Binary: ${detection.binaryPath}`));
     console.log(pc.gray(`  Version: ${detection.version || "unknown"}`));
     console.log("");
@@ -1105,8 +1250,8 @@ ${STEP} \u2014 Configure Agent
         }
       };
       state.itemStatus.set("codex", "unconfigured");
-      state.validationResults.set("codex", { ok: true, message: t("wizard.codex.disabled") });
-      console.log(pc.gray(`  ${t("wizard.codex.disabled")}
+      state.validationResults.set("codex", { ok: true, message: t("wizard.step.codex.disabled") });
+      console.log(pc.gray(`  ${t("wizard.step.codex.disabled")}
 `));
       return { action: "next", next: "cli-menu" };
     }
@@ -1127,8 +1272,8 @@ ${STEP} \u2014 Configure Agent
     };
     state.itemStatus.set("codex", "configured");
     state.sessionConfigured.add("codex");
-    state.validationResults.set("codex", { ok: true, message: t("wizard.codex.enabled") });
-    console.log(pc.green(`  ${t("wizard.codex.enabled")}
+    state.validationResults.set("codex", { ok: true, message: t("wizard.step.codex.enabled") });
+    console.log(pc.green(`  ${t("wizard.step.codex.enabled")}
 `));
     return { action: "next", next: "channel-select" };
   }
@@ -1154,7 +1299,7 @@ function injectClaudeHooks(settingsPath, events) {
     hooksConfig
   );
   mkdirSync4(dirname3(settingsPath), { recursive: true });
-  writeFileSync4(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(mergedSettings, null, 2));
 }
 var COMMAND_ONLY_HOOKS = ["SessionStart", "Setup"];
 function generateHooksConfig2(port, token, events) {
@@ -1188,7 +1333,7 @@ function cleanupClaudeHooks(settingsPath) {
     delete cleanedSettings.hooks;
   }
   mkdirSync4(dirname3(settingsPath), { recursive: true });
-  writeFileSync4(settingsPath, JSON.stringify(cleanedSettings, null, 2));
+  writeFileSync5(settingsPath, JSON.stringify(cleanedSettings, null, 2));
 }
 
 // src/cli/wizard/detectors/channel.ts
@@ -1288,20 +1433,20 @@ ${STEP2} \u2014 Configure Channel
       const botToken = await prompts.botToken(currentConfig.bot_token);
       const allowedUsers = await prompts.allowedUsers(String(currentConfig.allowed_users || ""));
       const userIds = allowedUsers.split(",").map((s) => s.trim()).filter((s) => s.length > 0 && /^\d+$/.test(s));
-      const spinner = ora2(t("wizard.channel.telegram.testing")).start();
+      const spinner = ora2(t("wizard.step.channel.telegram.testing")).start();
       let connected = false;
       try {
         const response = await fetch(`https://api.telegram.org/bot${botToken}/getMe`, {
           signal: AbortSignal.timeout(8e3)
         });
         if (!response.ok) {
-          spinner.fail(t("wizard.channel.telegram.apiError", { status: response.status }));
+          spinner.fail(t("wizard.step.channel.telegram.apiError", { status: response.status }));
         } else {
-          spinner.succeed(t("wizard.channel.telegram.connected"));
+          spinner.succeed(t("wizard.step.channel.telegram.connected"));
           connected = true;
         }
       } catch (err) {
-        spinner.fail(t("wizard.channel.telegram.connFailed", { error: String(err) }));
+        spinner.fail(t("wizard.step.channel.telegram.connFailed", { error: String(err) }));
       }
       if (!connected) {
         state.itemStatus.set(channelName, "error");
@@ -1312,21 +1457,23 @@ ${STEP2} \u2014 Configure Channel
         state.itemStatus.set(channelName, "unconfigured");
         return { action: "next", next: "channel-select" };
       }
-      const msgSpinner = ora2(t("wizard.channel.telegram.sendingTest")).start();
+      const msgSpinner = ora2(t("wizard.step.channel.telegram.sendingTest")).start();
       try {
         await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ chat_id: userIds[0] || 0, text: t("wizard.channel.telegram.testContent") }),
+          body: JSON.stringify({ chat_id: userIds[0] || 0, text: t("wizard.step.channel.telegram.testContent") }),
           signal: AbortSignal.timeout(8e3)
         });
-        msgSpinner.succeed(t("wizard.channel.telegram.testSent"));
+        msgSpinner.succeed(t("wizard.step.channel.telegram.testSent"));
       } catch {
-        msgSpinner.warn(t("wizard.channel.telegram.testWarning"));
+        msgSpinner.warn(t("wizard.step.channel.telegram.testWarning"));
       }
+      const existingEvents = Array.isArray(currentConfig.subscribed_events) ? currentConfig.subscribed_events : void 0;
+      const selectedEvents = await prompts.subscribedEventsSelect(existingEvents);
       state.pendingChanges.channel = {
         ...state.pendingChanges.channel || {},
-        telegram: { enabled: true, bot_token: botToken, allowed_users: userIds }
+        telegram: { enabled: true, bot_token: botToken, allowed_users: userIds, subscribed_events: selectedEvents }
       };
       state.itemStatus.set("telegram", "configured");
       state.sessionConfigured.add("telegram");
@@ -1347,15 +1494,17 @@ ${STEP2} \u2014 Configure Channel
       const appSecret = await prompts.feishuAppSecret(String(currentConfig.app_secret || ""));
       const allowedUsersInput = await prompts.feishuAllowedUsers(String(currentConfig.allowed_users || ""));
       if (!appId || !appSecret) {
-        console.log(pc3.yellow(`! ${t("wizard.channel.feishu.required")}
+        console.log(pc3.yellow(`! ${t("wizard.step.channel.feishu.required")}
 `));
         state.itemStatus.set("feishu", "unconfigured");
         return { action: "next", next: "channel-select" };
       }
       const allowedUsers = allowedUsersInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      const existingEvents = Array.isArray(currentConfig.subscribed_events) ? currentConfig.subscribed_events : void 0;
+      const selectedEvents = await prompts.subscribedEventsSelect(existingEvents);
       state.pendingChanges.channel = {
         ...state.pendingChanges.channel || {},
-        feishu: { enabled: true, app_id: appId, app_secret: appSecret, allowed_users: allowedUsers }
+        feishu: { enabled: true, app_id: appId, app_secret: appSecret, allowed_users: allowedUsers, subscribed_events: selectedEvents }
       };
       state.itemStatus.set("feishu", "configured");
       state.sessionConfigured.add("feishu");
@@ -1365,49 +1514,26 @@ ${STEP2} \u2014 Configure Channel
   }
 }
 
-// src/cli/wizard/steps/channel-notify.ts
-import pc4 from "picocolors";
-async function stepChannelNotify(state) {
-  const channelName = state.currentChannelName || "telegram";
-  console.log(pc4.bold(`
-${t("wizard.notify.title", { channel: channelName })}
-`));
-  const cfg = loadConfig();
-  const channelConfig = cfg.channel[channelName] || {};
-  const currentTypes = channelConfig.notify_types || [];
-  const selected = await prompts.notifyTypes(currentTypes);
-  if (!state.pendingChanges.channel) state.pendingChanges.channel = {};
-  if (!state.pendingChanges.channel[channelName]) state.pendingChanges.channel[channelName] = {};
-  state.pendingChanges.channel[channelName] = {
-    ...state.pendingChanges.channel[channelName],
-    notify_types: selected
-  };
-  console.log(pc4.green(`
-\u2713 ${t("wizard.notify.saved", { channel: channelName })}
-`));
-  return { action: "next", next: "channel-menu" };
-}
-
 // src/cli/wizard/steps/agent-select.ts
-import pc5 from "picocolors";
+import pc4 from "picocolors";
 var STEP3 = "STEP 1";
 async function stepAgentSelect(state) {
-  console.log(pc5.bold(`
+  console.log(pc4.bold(`
 ${STEP3} \u2014 Select Agent
 `));
-  console.log(pc5.gray(`${"\u2500".repeat(50)}
+  console.log(pc4.gray(`${"\u2500".repeat(50)}
 `));
   const config = loadConfig();
   const currentBindings = config.bindings ?? {};
   const agents = [];
   const claudeConfigured = !!config.agent.claude;
   const claudeBoundTo = currentBindings["claude"];
-  const claudeStatus = claudeBoundTo ? pc5.green(`[bound to ${claudeBoundTo}]`) : claudeConfigured ? pc5.green("[configured]") : pc5.gray("[not configured]");
+  const claudeStatus = claudeBoundTo ? pc4.green(`[bound to ${claudeBoundTo}]`) : claudeConfigured ? pc4.green("[configured]") : pc4.gray("[not configured]");
   agents.push({ name: "claude", value: "claude", status: claudeStatus });
   const codexDetection = detectCodex();
   const codexConfigured = !!config.agent.codex?.enabled;
   const codexBoundTo = currentBindings["codex"];
-  const codexStatus = codexBoundTo ? pc5.green(`[bound to ${codexBoundTo}]`) : codexConfigured ? pc5.green("[configured]") : codexDetection.installed ? pc5.gray("[not configured]") : pc5.red("[not installed]");
+  const codexStatus = codexBoundTo ? pc4.green(`[bound to ${codexBoundTo}]`) : codexConfigured ? pc4.green("[configured]") : codexDetection.installed ? pc4.gray("[not configured]") : pc4.red("[not installed]");
   agents.push({ name: "codex", value: "codex", status: codexStatus });
   const choice = await prompts.agentSelect(agents);
   state.currentAgentName = choice;
@@ -1430,13 +1556,13 @@ function getChannelInstanceId(channelType, credential) {
 }
 
 // src/cli/wizard/steps/channel-select.ts
-import pc6 from "picocolors";
+import pc5 from "picocolors";
 var STEP4 = "STEP 3";
 async function stepChannelSelect(state) {
-  console.log(pc6.bold(`
+  console.log(pc5.bold(`
 ${STEP4} \u2014 Select Channel
 `));
-  console.log(pc6.gray(`${"\u2500".repeat(50)}
+  console.log(pc5.gray(`${"\u2500".repeat(50)}
 `));
   const config = loadConfig();
   const currentBindings = config.bindings ?? {};
@@ -1448,22 +1574,22 @@ ${STEP4} \u2014 Select Channel
   const loggerEnabled = mergedLogger?.enabled === true;
   const loggerInstanceId = "logger:default";
   const loggerBoundAgent = Object.entries(currentBindings).find(([, v]) => v === loggerInstanceId)?.[0];
-  const loggerStatus = loggerBoundAgent ? pc6.green(`[bound to ${loggerBoundAgent}]`) : loggerEnabled ? pc6.green("[configured]") : pc6.gray("[not configured]");
+  const loggerStatus = loggerBoundAgent ? pc5.green(`[bound to ${loggerBoundAgent}]`) : loggerEnabled ? pc5.green("[configured]") : pc5.gray("[not configured]");
   if (mergedTelegram?.enabled && mergedTelegram.bot_token) {
     const instanceId = getChannelInstanceId("telegram", mergedTelegram.bot_token);
     const boundAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
-    const status = boundAgent ? pc6.green(`[bound to ${boundAgent}]`) : pc6.green("[configured]");
+    const status = boundAgent ? pc5.green(`[bound to ${boundAgent}]`) : pc5.green("[configured]");
     channels.push({ name: "telegram", value: "telegram", status });
   } else {
-    channels.push({ name: "telegram", value: "telegram", status: pc6.gray("[not configured]") });
+    channels.push({ name: "telegram", value: "telegram", status: pc5.gray("[not configured]") });
   }
   if (mergedFeishu?.enabled && mergedFeishu.app_id) {
     const instanceId = getChannelInstanceId("feishu", mergedFeishu.app_id);
     const boundAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
-    const status = boundAgent ? pc6.green(`[bound to ${boundAgent}]`) : pc6.green("[configured]");
+    const status = boundAgent ? pc5.green(`[bound to ${boundAgent}]`) : pc5.green("[configured]");
     channels.push({ name: "feishu", value: "feishu", status });
   } else {
-    channels.push({ name: "feishu", value: "feishu", status: pc6.gray("[not configured]") });
+    channels.push({ name: "feishu", value: "feishu", status: pc5.gray("[not configured]") });
   }
   channels.push({ name: "logger", value: "logger", status: loggerStatus });
   const choice = await prompts.channelSelect(channels);
@@ -1476,15 +1602,15 @@ ${STEP4} \u2014 Select Channel
 }
 
 // src/cli/wizard/steps/binding-confirm.ts
-import pc7 from "picocolors";
+import pc6 from "picocolors";
 var STEP5 = "STEP 5";
 async function stepBindingConfirm(state) {
   const agentName = state.currentAgentName;
   const channelName = state.currentChannelName;
-  console.log(pc7.bold(`
+  console.log(pc6.bold(`
 ${STEP5} \u2014 Confirm Binding
 `));
-  console.log(pc7.gray(`${"\u2500".repeat(50)}
+  console.log(pc6.gray(`${"\u2500".repeat(50)}
 `));
   const config = loadConfig();
   const currentBindings = { ...config.bindings ?? {} };
@@ -1507,8 +1633,8 @@ ${STEP5} \u2014 Confirm Binding
     instanceId = "logger:default";
     channelCurrentAgent = Object.entries(currentBindings).find(([, v]) => v === instanceId)?.[0];
   }
-  console.log(`  ${pc7.cyan(agentName)} current binding: ${agentCurrentChannel ? pc7.yellow(agentCurrentChannel) : pc7.gray("none")}`);
-  console.log(`  ${pc7.cyan(channelName)} current binding: ${channelCurrentAgent ? pc7.yellow(channelCurrentAgent) : pc7.gray("none")}`);
+  console.log(`  ${pc6.cyan(agentName)} current binding: ${agentCurrentChannel ? pc6.yellow(agentCurrentChannel) : pc6.gray("none")}`);
+  console.log(`  ${pc6.cyan(channelName)} current binding: ${channelCurrentAgent ? pc6.yellow(channelCurrentAgent) : pc6.gray("none")}`);
   console.log("");
   const choice = await prompts.bindingConfirm(agentName, channelName);
   if (choice === "confirm" && instanceId) {
@@ -1519,26 +1645,26 @@ ${STEP5} \u2014 Confirm Binding
       }
     }
     if (oldChannelId && oldChannelId !== instanceId) {
-      console.log(pc7.yellow(`  \u26A0 ${agentName} migrated from ${oldChannelId} to ${instanceId}`));
+      console.log(pc6.yellow(`  \u26A0 ${agentName} migrated from ${oldChannelId} to ${instanceId}`));
     }
     state.bindings[agentName] = instanceId;
     state.sessionConfigured.add(`binding:${agentName}`);
-    console.log(pc7.green(`  \u2713 ${agentName} bound to ${channelName}`));
+    console.log(pc6.green(`  \u2713 ${agentName} bound to ${channelName}`));
   } else {
-    console.log(pc7.gray(`  Binding cancelled`));
+    console.log(pc6.gray(`  Binding cancelled`));
   }
   console.log("");
   return { action: "next", next: "pair-continue" };
 }
 
 // src/cli/wizard/steps/pair-continue.ts
-import pc8 from "picocolors";
+import pc7 from "picocolors";
 var STEP6 = "STEP 6";
 async function stepPairContinue(state) {
-  console.log(pc8.bold(`
+  console.log(pc7.bold(`
 ${STEP6} \u2014 Add Another Pair?
 `));
-  console.log(pc8.gray(`${"\u2500".repeat(50)}
+  console.log(pc7.gray(`${"\u2500".repeat(50)}
 `));
   const choice = await prompts.pairContinue();
   if (choice === "continue") {
@@ -1557,7 +1683,7 @@ import { fileURLToPath } from "url";
 import { mkdirSync as mkdirSync5, existsSync as existsSync7 } from "fs";
 
 // src/shared/pidfile.ts
-import { writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync6, unlinkSync } from "fs";
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync6, existsSync as existsSync6, unlinkSync } from "fs";
 function readPidFile(pidFilePath) {
   if (!existsSync6(pidFilePath)) {
     return null;
@@ -1591,6 +1717,18 @@ function isPortInUse(port) {
     });
   });
 }
+async function isHttpReady(port, timeoutMs = 2e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`http://localhost:${port}/health`, { signal: controller.signal });
+    clearTimeout(timer);
+    return response.ok;
+  } catch {
+    clearTimeout(timer);
+    return false;
+  }
+}
 var DaemonManager = class {
   pidFilePath;
   port;
@@ -1622,12 +1760,18 @@ var DaemonManager = class {
     const existingPidData = readPidFile(this.pidFilePath);
     if (existingPidData && isProcessRunning(existingPidData.pid)) {
       if (!existingPidData.token) {
-        console.log(t("daemon.lackingToken"));
+        console.log(t("cli.daemon.lackingToken"));
         await this.stop();
         await this.waitForPortFree();
       } else {
-        console.log(t("daemon.alreadyRunning"));
-        return true;
+        const ready = await isHttpReady(this.port, 3e3);
+        if (ready) {
+          console.log(t("cli.daemon.alreadyRunning"));
+          return true;
+        }
+        console.log(t("cli.daemon.staleProcess"));
+        await this.stop();
+        await this.waitForPortFree();
       }
     }
     try {
@@ -1641,7 +1785,7 @@ var DaemonManager = class {
         daemonScript = join6(__dirname3, "..", "..", "src", "gateway", "process.ts");
       }
       if (!existsSync7(daemonScript)) {
-        this.lastError = t("daemon.scriptNotFound", { path: daemonScript });
+        this.lastError = t("cli.daemon.scriptNotFound", { path: daemonScript });
         console.error(this.lastError);
         return false;
       }
@@ -1660,23 +1804,26 @@ var DaemonManager = class {
       });
       child.unref();
       let pidData = null;
-      for (let i = 0; i < 30; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      for (let i = 0; i < 150; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 200));
         pidData = readPidFile(this.pidFilePath);
         if (pidData) {
           if (isProcessRunning(pidData.pid)) {
-            console.log(t("daemon.startedOnPort", { port: this.port }));
-            return true;
+            const httpReady = await isHttpReady(this.port, 2e3);
+            if (httpReady) {
+              console.log(t("cli.daemon.startedOnPort", { port: this.port }));
+              return true;
+            }
           }
         }
       }
-      this.lastError = t("daemon.startFailed");
+      this.lastError = t("cli.daemon.startFailed");
       console.error(this.lastError);
-      console.error(t("daemon.checkLogs", { path: logFile }));
+      console.error(t("cli.daemon.checkLogs", { path: logFile }));
       return false;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      this.lastError = t("daemon.startError", { error: errorMsg });
+      this.lastError = t("cli.daemon.startError", { error: errorMsg });
       console.error(this.lastError);
       return false;
     }
@@ -1709,7 +1856,7 @@ var DaemonManager = class {
     const startTime = Date.now();
     while (await isPortInUse(this.port)) {
       if (Date.now() - startTime > maxWaitMs) {
-        console.log(t("daemon.portInUse", { port: this.port, ms: maxWaitMs }));
+        console.log(t("cli.daemon.portInUse", { port: this.port, ms: maxWaitMs }));
         break;
       }
       await new Promise((resolve) => setTimeout(resolve, 200));
@@ -1720,20 +1867,20 @@ var DaemonManager = class {
 // src/cli/wizard/steps/final.ts
 import { join as join7 } from "path";
 import { homedir as homedir6 } from "os";
-import pc9 from "picocolors";
+import pc8 from "picocolors";
 import ora3 from "ora";
 async function stepFinal(state) {
-  console.log(pc9.bold(`
+  console.log(pc8.bold(`
 ${t("wizard.section.complete")}
 `));
   if (state.sessionConfigured.size === 0) {
-    console.log(pc9.gray(`  ${t("wizard.final.noItems")}
+    console.log(pc8.gray(`  ${t("wizard.step.final.noItems")}
 `));
   } else {
     for (const item of state.sessionConfigured) {
       const result = state.validationResults.get(item);
       if (result?.ok) {
-        console.log(pc9.green(`* ${t("wizard.final.itemOk", { item })}`));
+        console.log(pc8.green(`* ${t("wizard.step.final.itemOk", { item })}`));
       }
     }
     console.log("");
@@ -1744,74 +1891,74 @@ ${t("wizard.section.complete")}
   const hasChanges = state.sessionConfigured.size > 0 || Object.keys(state.pendingChanges).length > 0 || Object.keys(state.bindings).length > 0;
   if (daemon.isRunning()) {
     if (hasChanges) {
-      console.log(pc9.blue(`i ${t("wizard.final.runningChanges")}
+      console.log(pc8.blue(`i ${t("wizard.step.final.runningChanges")}
 `));
-      console.log(pc9.yellow(`  ${t("wizard.final.configModified")}
+      console.log(pc8.yellow(`  ${t("wizard.step.final.configModified")}
 `));
       const shouldRestart = await prompts.restartGateway();
       if (shouldRestart) {
-        const spinner = ora3(t("wizard.final.restarting")).start();
+        const spinner = ora3(t("wizard.step.final.restarting")).start();
         await daemon.stop();
         const started = await daemon.start();
         if (started) {
-          spinner.succeed(t("wizard.final.restarted"));
+          spinner.succeed(t("wizard.step.final.restarted"));
         } else {
-          spinner.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
+          spinner.fail(t("wizard.step.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
         }
       } else {
-        console.log(pc9.gray(`  ${t("wizard.final.restartTip")}
+        console.log(pc8.gray(`  ${t("wizard.step.final.restartTip")}
 `));
       }
     } else {
-      console.log(pc9.blue(`i ${t("wizard.final.running")}
+      console.log(pc8.blue(`i ${t("wizard.step.final.running")}
 `));
-      console.log(pc9.green(`  ${t("wizard.final.runningReady")}
+      console.log(pc8.green(`  ${t("wizard.step.final.runningReady")}
 `));
     }
   } else {
-    console.log(pc9.blue(`i ${t("wizard.final.notRunning")}
+    console.log(pc8.blue(`i ${t("wizard.step.final.notRunning")}
 `));
     if (hasChanges) {
-      console.log(pc9.yellow(`  ${t("wizard.final.configModifiedStart")}
+      console.log(pc8.yellow(`  ${t("wizard.step.final.configModifiedStart")}
 `));
     }
     const shouldStart = await prompts.restartGateway();
     if (shouldStart) {
-      const spinner2 = ora3(t("wizard.final.starting")).start();
+      const spinner2 = ora3(t("wizard.step.final.starting")).start();
       const started = await daemon.start();
       if (started) {
-        spinner2.succeed(t("wizard.final.started"));
+        spinner2.succeed(t("wizard.step.final.started"));
       } else {
-        spinner2.fail(t("wizard.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
+        spinner2.fail(t("wizard.step.final.startFailed", { error: daemon.getLastError() ?? "unknown" }));
       }
     } else {
-      console.log(pc9.gray(`  ${t("wizard.final.startTip")}
+      console.log(pc8.gray(`  ${t("wizard.step.final.startTip")}
 `));
     }
   }
-  console.log(pc9.green(`
-${t("wizard.final.done")}
+  console.log(pc8.green(`
+${t("wizard.step.final.done")}
 `));
   return { action: "next", next: "done" };
 }
 
 // src/cli/wizard/steps/permission-mode.ts
-import pc10 from "picocolors";
+import pc9 from "picocolors";
 var STEP7 = "STEP 3";
 async function stepPermissionMode(state) {
-  console.log(pc10.bold(`
+  console.log(pc9.bold(`
 ${STEP7} \u2014 Permission Mode
 `));
-  console.log(pc10.gray(`${"\u2500".repeat(50)}
+  console.log(pc9.gray(`${"\u2500".repeat(50)}
 `));
   const config = loadConfig();
   const current = state.pendingChanges?.agent?.claude;
   const saved = current?.permission_mode ?? config.agent.claude?.permission_mode ?? null;
   const detected = detectPermissionMode();
   const initial = saved ?? detected ?? "acceptEdits";
-  console.log(pc10.gray("Controls how Claude Code handles permission requests.\n"));
+  console.log(pc9.gray("Controls how Claude Code handles permission requests.\n"));
   if (detected && !saved) {
-    console.log(pc10.gray(`Detected from ~/.claude/settings.json: ${detected}
+    console.log(pc9.gray(`Detected from ~/.claude/settings.json: ${detected}
 `));
   }
   const selected = await prompts.permissionModeSelect(initial);
@@ -1888,8 +2035,6 @@ var WizardEngine = class {
         return await stepCliMenu(this.state);
       case "channel-config":
         return await stepChannelConfig(this.state);
-      case "channel-notify":
-        return await stepChannelNotify(this.state);
       case "final":
         return await stepFinal(this.state);
       default:
@@ -2171,29 +2316,29 @@ var statusCommand = new Command4("status").description("Show current status").ac
   const pidFilePath = join11(homedir10(), ".handsoff", "handsoff.pid");
   const daemon = new DaemonManager(pidFilePath, config.general.hook_server_port);
   console.log(`
-${t("status.title")}
+${t("cli.status.title")}
 `);
-  console.log(daemon.isRunning() ? t("status.daemon.running") : t("status.daemon.notRunning"));
-  console.log(t("status.port", { port: config.general.hook_server_port }));
-  console.log(`${t("status.logLevel", { level: config.general.log_level })}
+  console.log(daemon.isRunning() ? t("cli.status.daemon.running") : t("cli.status.daemon.notRunning"));
+  console.log(t("cli.status.port", { port: config.general.hook_server_port }));
+  console.log(`${t("cli.status.logLevel", { level: config.general.log_level })}
 `);
-  console.log(t("status.channels"));
-  console.log(`  ${config.channel.telegram?.enabled ? t("status.telegram.enabled") : t("status.telegram.disabled")}`);
-  console.log(`  ${config.channel.feishu?.enabled ? t("status.feishu.enabled") : t("status.feishu.disabled")}
+  console.log(t("cli.status.channels"));
+  console.log(`  ${config.channel.telegram?.enabled ? t("cli.status.telegram.enabled") : t("cli.status.telegram.disabled")}`);
+  console.log(`  ${config.channel.feishu?.enabled ? t("cli.status.feishu.enabled") : t("cli.status.feishu.disabled")}
 `);
   const settingsPath = getSettingsPath2();
   const backupPath = settingsPath + ".handsoff-backup";
   if (existsSync11(backupPath)) {
-    console.log(t("status.settingsBackup"));
+    console.log(t("cli.status.settingsBackup"));
   } else {
-    console.log(t("status.settingsNoBackup"));
+    console.log(t("cli.status.settingsNoBackup"));
   }
   const home = homedir10();
   console.log(`
-${t("status.paths")}`);
-  console.log(`  ${t("status.pathConfig", { path: `${home}/.handsoff/config.toml` })}`);
-  console.log(`  ${t("status.pathLogs", { path: `${home}/.handsoff/logs/gateway.log` })}`);
-  console.log(`  ${t("status.pathBackup", { path: `${home}/.claude/settings.json.handsoff-backup` })}
+${t("cli.status.paths")}`);
+  console.log(`  ${t("cli.status.pathConfig", { path: `${home}/.handsoff/config.toml` })}`);
+  console.log(`  ${t("cli.status.pathLogs", { path: `${home}/.handsoff/logs/gateway.log` })}`);
+  console.log(`  ${t("cli.status.pathBackup", { path: `${home}/.claude/settings.json.handsoff-backup` })}
 `);
 });
 
@@ -2229,20 +2374,20 @@ var gatewayCommand = new Command6("gateway").description("Manage handsoff Gatewa
     const port = options.port ? parseInt(options.port, 10) : config.general.hook_server_port;
     const daemon = new DaemonManager(PID_FILE, port);
     if (daemon.isRunning()) {
-      console.log(t("gateway.stopping"));
+      console.log(t("cli.gateway.stopping"));
       await daemon.stop();
     }
     const started = await daemon.start();
     if (started) {
-      console.log(t("gateway.startedOnPort", { port }));
+      console.log(t("cli.gateway.startedOnPort", { port }));
     } else {
       const error = daemon.getLastError();
-      console.error(t("gateway.startFailed"));
+      console.error(t("cli.gateway.startFailed"));
       if (error) {
-        console.error(t("gateway.error", { error }));
+        console.error(t("cli.gateway.error", { error }));
       }
       const logPath = join13(homedir12(), ".handsoff", "logs", "gateway.log");
-      console.error(`  ${t("gateway.checkLogs", { path: logPath })}`);
+      console.error(`  ${t("cli.gateway.checkLogs", { path: logPath })}`);
       process.exit(1);
     }
   })
@@ -2251,15 +2396,15 @@ var gatewayCommand = new Command6("gateway").description("Manage handsoff Gatewa
     const config = loadConfig();
     const daemon = new DaemonManager(PID_FILE, config.general.hook_server_port);
     if (!daemon.isRunning()) {
-      console.log(t("gateway.notRunning"));
+      console.log(t("cli.gateway.notRunning"));
       return;
     }
-    console.log(t("gateway.stopping"));
+    console.log(t("cli.gateway.stopping"));
     const stopped = await daemon.stop();
     if (stopped) {
-      console.log(t("gateway.stopped"));
+      console.log(t("cli.gateway.stopped"));
     } else {
-      console.error(t("gateway.stopFailed"));
+      console.error(t("cli.gateway.stopFailed"));
       process.exit(1);
     }
   })
@@ -2271,15 +2416,15 @@ var gatewayCommand = new Command6("gateway").description("Manage handsoff Gatewa
     await daemon.stop();
     const started = await daemon.start();
     if (started) {
-      console.log(t("gateway.restartedOnPort", { port }));
+      console.log(t("cli.gateway.restartedOnPort", { port }));
     } else {
       const error = daemon.getLastError();
-      console.error(t("gateway.restartFailed"));
+      console.error(t("cli.gateway.restartFailed"));
       if (error) {
-        console.error(t("gateway.error", { error }));
+        console.error(t("cli.gateway.error", { error }));
       }
       const logPath = join13(homedir12(), ".handsoff", "logs", "gateway.log");
-      console.error(`  ${t("gateway.checkLogs", { path: logPath })}`);
+      console.error(`  ${t("cli.gateway.checkLogs", { path: logPath })}`);
       process.exit(1);
     }
   })
@@ -2290,13 +2435,13 @@ var gatewayCommand = new Command6("gateway").description("Manage handsoff Gatewa
       const response = await fetch(`http://localhost:${config.general.hook_server_port}/status`);
       if (response.ok) {
         const status = await response.json();
-        console.log(t("gateway.status.title"));
-        console.log(`  ${t("gateway.status.running", { value: status.running ?? true })}`);
-        console.log(`  ${t("gateway.status.sessions", { count: status.sessions?.length ?? (typeof status.sessions === "number" ? status.sessions : 0) })}`);
-        console.log(`  ${t("gateway.status.clients", { count: status.clients ?? 0 })}`);
+        console.log(t("cli.gateway.status.title"));
+        console.log(`  ${t("cli.gateway.status.running", { value: status.running ?? true })}`);
+        console.log(`  ${t("cli.gateway.status.sessions", { count: status.sessions?.length ?? (typeof status.sessions === "number" ? status.sessions : 0) })}`);
+        console.log(`  ${t("cli.gateway.status.clients", { count: status.clients ?? 0 })}`);
         if (status.sessions && status.sessions.length > 0) {
           console.log(`
-  ${t("gateway.status.activeSessions")}`);
+  ${t("cli.gateway.status.activeSessions")}`);
           for (const session of status.sessions) {
             const agentType = session.agentType || "unknown";
             const sessionId = session.sessionId || session.id || "unknown";
@@ -2304,10 +2449,10 @@ var gatewayCommand = new Command6("gateway").description("Manage handsoff Gatewa
           }
         }
       } else {
-        console.log(t("gateway.status.notResponding"));
+        console.log(t("cli.gateway.status.notResponding"));
       }
     } catch {
-      console.log(t("gateway.status.notRunning"));
+      console.log(t("cli.gateway.status.notRunning"));
     }
   })
 );
@@ -2344,19 +2489,19 @@ var debugCommand = new Command7("debug").description("Debug tools for Handsoff")
 import { spawn as spawn3 } from "child_process";
 import { homedir as homedir13 } from "os";
 import { join as join15, dirname as dirname6 } from "path";
-import { readFileSync as readFileSync7, existsSync as existsSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
 function getSettingsPath3() {
   return join15(homedir13(), ".claude", "settings.json");
 }
 function backupSettings2(settingsPath) {
   const backupPath = settingsPath + ".handsoff-backup";
   if (existsSync12(settingsPath)) {
-    writeFileSync6(backupPath, readFileSync7(settingsPath, "utf-8"));
+    writeFileSync7(backupPath, readFileSync7(settingsPath, "utf-8"));
   }
 }
 function writeSettings2(settingsPath, settings) {
   mkdirSync6(dirname6(settingsPath), { recursive: true });
-  writeFileSync6(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync7(settingsPath, JSON.stringify(settings, null, 2));
 }
 function generateHooksConfig3(port, token) {
   const unifiedUrl = `http://localhost:${port}/hook/${token}/event`;