oomi-ai 0.7.2 → 0.8.1

package/bin/oomi-ai.js

@@ -8,10 +8,13 @@ import net from 'net';
 import { lookup as dnsLookup } from 'dns/promises';
 import { fileURLToPath } from 'url';
 import WebSocket from 'ws';
+import { planPackageUpdate, isWorkerDescendant, queueRestart, readMaintenance, createMaintenanceController } from '../lib/bridgeMaintenance.js';
+import { bridgeServiceConfig, createBridgeService, renderLaunchAgent } from '../lib/bridgeService.js';
 import { LOCAL_PROTOCOL_MIN, LOCAL_PROTOCOL_MAX, probeGateway } from '../lib/gatewayProbe.js';
 import { LocalAgentRuntime, localAgentConfig, runLocalAgent, writePrivateJson, startChannelWorker } from '../lib/localAgent.js';
 import { validateAgentName, identityRequest, startIdentityWorker, handleIdentityCommand } from '../lib/agentIdentity.js';
 import { handleSpacesCommand, compactHealth } from '../lib/spaces.js';
+import { handleObjectivesCommand } from '../lib/objectives.js';
 import { handleRoutinesCommand, startRoutineEventWorker } from '../lib/routines.js';
 import { createPersonaApiClient } from '../lib/personaApiClient.js';
 import { inferSpokenMetadataFromContent, normalizeSpokenMetadata } from '../lib/spokenMetadata.js';
@@ -59,7 +62,6 @@ const BRIDGE_GATEWAY_REQUEST_TIMEOUT_MS = parsePositiveInteger(
   process.env.OOMI_BRIDGE_GATEWAY_REQUEST_TIMEOUT_MS,
   30000
 );
-const BRIDGE_LAUNCHD_LABEL = 'ai.oomi.bridge';
 const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
 const BRIDGE_DEBUG_ENABLED = process.env.OOMI_BRIDGE_DEBUG === '1';
 
@@ -192,8 +194,7 @@ async function maybeNotifyUpdate(command) {
 
   if (compareVersions(currentVersion, latestVersion) < 0) {
     console.warn(`[oomi] Update available: oomi-ai ${currentVersion} -> ${latestVersion}`);
-    console.warn('[oomi] Update command: pnpm add -g oomi-ai@latest');
-    console.warn('[oomi] Fallback update command: npm install -g oomi-ai@latest');
+    console.warn('[oomi] Read the safe update plan: oomi update');
   }
 }
 
@@ -201,11 +202,14 @@ function usage() {
   console.log(`oomi <command>
 
 Commands:
+  update
+    Check for a newer package and return a safe, approval-preserving update plan.
   connect --runtime openclaw|hermes|command [--name CONNECTION] [--agent-name "Your name"] [--app-url URL]
     Verify the selected local agent, pair once, start its bridge, and return an Auth Link.
     Hermes: --profile PROFILE and --resume SESSION select the intended agent/session.
     Other agents: --command '["/absolute/path/to/adapter"]' (JSON stdin / JSON stdout).
     --cwd PATH selects the agent working directory; --name isolates multiple agents.
+    Installs automatic startup on macOS/Linux. --no-service opts into external supervision.
   status [--name NAME]
     Show broker connection and verified local agent health separately.
   verify [--name NAME]
@@ -217,8 +221,10 @@ Commands:
   identity restore --snapshot ID --output NEW_FOLDER [--connection NAME]
   invite [--name NAME] [--app-url URL]
     Generate a fresh Auth Link from saved pairing without changing agents.
-  bridge [start|ensure|stop|restart|ps] [--name NAME] [--detach]
-    Manage only the named agent's bridge.
+  bridge [start|ensure|stop|restart|repair|list|ps] [--name NAME] [--detach]
+    Manage only the named agent's bridge. Repair restores supervision without re-pairing.
+  bridge service [install|start|stop|restart|status|uninstall] [--name NAME]
+    Manage automatic restart and startup (macOS launchd / Linux systemd user).
 
   init
     Install Oomi agent instructions into OpenClaw AGENTS.md.
@@ -229,7 +235,7 @@ Commands:
   openclaw bridge [start|ensure|stop|restart|ps]
     Manage local OpenClaw-to-Oomi bridge lifecycle (singleton).
   openclaw bridge service [install|start|stop|restart|status|uninstall]
-    Manage macOS launchd bridge supervision.
+    Legacy alias for bridge service, with the same connection isolation.
   openclaw profile init
     Write a deterministic OpenClaw profile for local/dev or hosted setup flows.
   openclaw profile apply
@@ -265,12 +271,18 @@ Commands:
   updates
     Read quiet state updates; does not start a model turn.
   spaces list|catalog|show <id>|revisions <id>
-  spaces create|update|archive|unarchive|restore [id] --file PATH
+  spaces create|update|archive|unarchive|restore|upgrade [id] --file PATH
+    [--schema-version space.v3]  Required for goals/streaks; v2 remains supported for sources
+  objectives list|show <id>
+  objectives history <id> [--before YYYY-MM-DD]
+  objectives create|update|respond [id] --file PATH
+    [--source-message ID]  Owner instruction required for agent-recorded progress/corrections
     Choose components from catalog. Writes require idempotencyKey and updates require expectedRevision.
 
   context health [--window day|week|month|year|all|range] [--date YYYY-MM-DD]
     [--from YYYY-MM-DD --to YYYY-MM-DD] [--shape summary|series|both]
     [--group-by day|week|month|year] [--timezone IANA-zone] [--cursor YYYY-MM-DD]
+    [--provider all|apple_health|smart_scale]
     [--metric steps|weight|sleep|canonical.metric] [--output PATH]
     Show the latest account-linked health context available to this paired OpenClaw device.
   context plugins [--plugin apple_calendar|apple_reminders|apple_contacts|apple_location|apple_notes|google_gmail|google_drive|google_calendar|bluetooth_devices]
@@ -623,6 +635,7 @@ async function handleContextHealthCommand(flags = {}) {
   const payload = await client.getHealthContext({
     window: flags.window, date: flags.date, from: flags.from, to: flags.to,
     shape: flags.shape, groupBy: flags['group-by'], timezone: flags.timezone, cursor: flags.cursor,
+    provider: flags.provider,
   });
   const result = flags.metric ? compactHealth(payload, flags.metric) : payload;
   if (flags.output) {
@@ -692,19 +705,16 @@ async function handleContextHealthSyncCommand(flags = {}) {
 
 async function refreshBridgeForUpdate(flags = {}, options = {}) {
   const logger = options.logger || null;
-  if (process.platform === 'darwin') {
-    const launchdStatus = readBridgeLaunchdStatus();
-    if (launchdStatus.installed) {
-      logger?.(`Restarting launchd-managed bridge ${launchdStatus.target}.`);
-      await stopBridgeLaunchdService();
-      startBridgeLaunchdService();
-      incrementBridgeMetric('bridge_restart_count');
-      return {
-        restarted: true,
-        mode: 'service',
-        target: launchdStatus.target,
-      };
-    }
+  const service = currentBridgeService();
+  const deferred = deferLiveRestart({ print: false });
+  if (deferred) return { queued: true, maintenance: deferred };
+  assertIndependentMaintenance();
+  if (service.status().installed) {
+    logger?.(`Restarting supervised bridge ${service.config.target}.`);
+    await stopSupervisedBridge(service);
+    service.start({ rewrite: true });
+    incrementBridgeMetric('bridge_restart_count');
+    return { restarted: true, mode: 'service', target: service.config.target };
   }
 
   const running = findRunningBridgeProcess();
@@ -766,6 +776,7 @@ async function handleOpenclawRefreshCommand(flags = {}) {
     return;
   }
 
+  if (payload.bridge.queued) { console.log(payload.bridge.maintenance.message); return; }
   console.log(`Oomi refresh complete (${payload.currentVersion})`);
   if (payload.bridge.restarted) {
     console.log(`Bridge restarted (${payload.bridge.mode}).`);
@@ -843,8 +854,15 @@ function resolveBridgeLiveLogPath() {
   return bridgeConnectionName ? path.join(connectionDirectory(), 'logs', 'oomi-bridge-live.log') : resolveOpenclawBridgeLiveLogPath();
 }
 
-function resolveBridgeLaunchAgentPlistPath() {
-  return path.join(os.homedir(), 'Library', 'LaunchAgents', `${BRIDGE_LAUNCHD_LABEL}.plist`);
+function currentBridgeService() {
+  return createBridgeService(bridgeServiceConfig({
+    name: bridgeConnectionName, stateDirectory: path.dirname(resolveBridgeStatePath()),
+    logPath: resolveBridgeLiveLogPath(), scriptPath: fileURLToPath(import.meta.url),
+  }));
+}
+
+function buildBridgeLaunchAgentPlist() {
+  return renderLaunchAgent(currentBridgeService().config);
 }
 
 function defaultDeviceId() {
@@ -2418,142 +2436,6 @@ async function stopBridgeProcesses() {
   };
 }
 
-function assertMacOSLaunchdAvailable() {
-  if (process.platform !== 'darwin') {
-    throw new Error('Bridge service manager is only supported on macOS (launchd).');
-  }
-  if (typeof process.getuid !== 'function') {
-    throw new Error('Cannot resolve current UID for launchd domain.');
-  }
-}
-
-function launchctlDomain() {
-  assertMacOSLaunchdAvailable();
-  return `gui/${String(process.getuid())}`;
-}
-
-function launchctlServiceTarget() {
-  return `${launchctlDomain()}/${BRIDGE_LAUNCHD_LABEL}`;
-}
-
-function runLaunchctl(args, { allowFailure = false } = {}) {
-  const result = spawnSync('launchctl', args, {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  const status = Number.isInteger(result.status) ? result.status : 1;
-  const stdout = String(result.stdout || '').trim();
-  const stderr = String(result.stderr || '').trim();
-  if (status !== 0 && !allowFailure) {
-    throw new Error(
-      `launchctl ${args.join(' ')} failed (${status}): ${stderr || stdout || 'unknown launchctl error'}`
-    );
-  }
-  return { status, stdout, stderr };
-}
-
-function buildBridgeLaunchAgentPlist() {
-  const scriptPath = (() => {
-    try {
-      return fs.realpathSync(process.argv[1]);
-    } catch {
-      return process.argv[1];
-    }
-  })();
-  const programArgs = [process.execPath, scriptPath, 'openclaw', 'bridge', 'start', '--service-managed'];
-  const bridgeLogPath = resolveBridgeLiveLogPath();
-  const argsXml = programArgs.map((arg) => `<string>${xmlEscape(arg)}</string>`).join('\n      ');
-  const openclawHome = resolveOpenclawHome();
-  const openclawWorkspace = resolveOpenclawWorkspaceRoot();
-  const envVars = {
-    OOMI_SKIP_UPDATE_CHECK: '1',
-  };
-  if (process.env.OPENCLAW_HOME) {
-    envVars.OPENCLAW_HOME = openclawHome;
-  }
-  if (process.env.OPENCLAW_WORKSPACE) {
-    envVars.OPENCLAW_WORKSPACE = openclawWorkspace;
-  }
-  const envXml = Object.entries(envVars)
-    .map(([key, value]) => `    <key>${xmlEscape(key)}</key>\n    <string>${xmlEscape(value)}</string>`)
-    .join('\n');
-
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${xmlEscape(BRIDGE_LAUNCHD_LABEL)}</string>
-  <key>ProgramArguments</key>
-  <array>
-      ${argsXml}
-  </array>
-  <key>WorkingDirectory</key>
-  <string>${xmlEscape(openclawHome)}</string>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>ThrottleInterval</key>
-  <integer>5</integer>
-  <key>EnvironmentVariables</key>
-  <dict>
-${envXml}
-  </dict>
-  <key>StandardOutPath</key>
-  <string>${xmlEscape(bridgeLogPath)}</string>
-  <key>StandardErrorPath</key>
-  <string>${xmlEscape(bridgeLogPath)}</string>
-</dict>
-</plist>
-`;
-}
-
-function readBridgeLaunchdStatus() {
-  assertMacOSLaunchdAvailable();
-  const plistPath = resolveBridgeLaunchAgentPlistPath();
-  const target = launchctlServiceTarget();
-  const printResult = runLaunchctl(['print', target], { allowFailure: true });
-  const loaded = printResult.status === 0;
-  const output = [printResult.stdout, printResult.stderr].filter(Boolean).join('\n');
-  const pidMatch = output.match(/\bpid\s*=\s*(\d+)/);
-  const lastExitMatch = output.match(/\blast exit code\s*=\s*(-?\d+)/i);
-
-  return {
-    plistPath,
-    target,
-    installed: fs.existsSync(plistPath),
-    loaded,
-    pid: pidMatch ? Number(pidMatch[1]) : null,
-    running: Boolean(pidMatch && Number(pidMatch[1]) > 0),
-    lastExitCode: lastExitMatch ? Number(lastExitMatch[1]) : null,
-    printOutput: output,
-  };
-}
-
-function startBridgeLaunchdService() {
-  assertMacOSLaunchdAvailable();
-  const plistPath = resolveBridgeLaunchAgentPlistPath();
-  if (!fs.existsSync(plistPath)) {
-    throw new Error('Bridge service is not installed. Run: oomi openclaw bridge service install');
-  }
-  writeFile(plistPath, buildBridgeLaunchAgentPlist());
-  const domain = launchctlDomain();
-  const target = launchctlServiceTarget();
-  runLaunchctl(['bootout', domain, plistPath], { allowFailure: true });
-  runLaunchctl(['bootstrap', domain, plistPath]);
-  runLaunchctl(['enable', target], { allowFailure: true });
-  runLaunchctl(['kickstart', '-k', target], { allowFailure: true });
-}
-
-async function stopBridgeLaunchdService() {
-  assertMacOSLaunchdAvailable();
-  const plistPath = resolveBridgeLaunchAgentPlistPath();
-  const domain = launchctlDomain();
-  runLaunchctl(['bootout', domain, plistPath], { allowFailure: true });
-  return stopBridgeProcesses();
-}
-
 async function resolveBridgeRuntimeConfig(flags, bridgeState) {
   const explicitBrokerHttp = String(flags['broker-http'] || '').trim();
   const explicitBrokerWs = String(flags['broker-ws'] || '').trim();
@@ -2706,15 +2588,24 @@ async function startOpenclawBridge(flags) {
     consecutiveFailures: 0,
     pid: process.pid,
     startedAt: bridgeNowIso(),
+    packageVersion: currentPackageVersion(),
+    maintenanceProtocol: 1,
   });
 
+  try { refreshSelectedSkill(bridgeState); } catch (err) { console.warn('Oomi skill refresh failed:', err.message); }
   console.log(`Starting ${bridgeState.runtime || 'openclaw'} bridge: device=${deviceId}`);
+  let backgroundTurns = 0;
+  const deliverAgentEvent = async (turn) => {
+    backgroundTurns++;
+    try { return await (localRuntime ? localRuntime.turn(turn) : probeGateway({ gateway, deviceIdentity: gatewayDeviceIdentity, prepareFrame: prepareGatewayFrameForLocalGateway, turn, timeoutMs: 180000 })); }
+    finally { backgroundTurns--; }
+  };
   const stopChannelWorker = localRuntime ? startChannelWorker(bridgeState, localRuntime) : () => {};
   const stopIdentityWorker = startIdentityWorker({
     state: { ...bridgeState, brokerHttp, deviceToken },
     receiptPath: path.join(path.dirname(resolveBridgeStatePath()), 'oomi-identity-receipt.json'),
     // Applying a specific settings revision is idempotent, unlike a user turn.
-    deliver: (turn) => localRuntime ? localRuntime.turn({ ...turn, retryInterrupted: false }) : probeGateway({ gateway, deviceIdentity: gatewayDeviceIdentity, prepareFrame: prepareGatewayFrameForLocalGateway, turn, timeoutMs: 180000 }),
+    deliver: deliverAgentEvent,
     acknowledgeCommand: (identity) => `oomi identity acknowledge${bridgeConnectionName ? ` --connection ${bridgeConnectionName}` : ''} --identity-id ${identity.identityId} --revision ${identity.revision}`,
     onError: () => updateBridgeStatus({ identitySyncError: 'Identity notice was interrupted. Read oomi identity get in your agent to apply and acknowledge the pending revision; no model retry was sent.' }),
   });
@@ -2722,7 +2613,7 @@ async function startOpenclawBridge(flags) {
     state: { ...bridgeState, brokerHttp, deviceToken },
     connection: bridgeConnectionName,
     receiptPath: path.join(path.dirname(resolveBridgeStatePath()), 'oomi-routine-receipt.json'),
-    deliver: (turn) => localRuntime ? localRuntime.turn(turn) : probeGateway({ gateway, deviceIdentity: gatewayDeviceIdentity, prepareFrame: prepareGatewayFrameForLocalGateway, turn, timeoutMs: 180000 }),
+    deliver: deliverAgentEvent,
     onError: () => updateBridgeStatus({ routineSyncError: 'Routine updates are waiting for the runtime. They will retry.' }),
   });
   console.log(`Local gateway: ${gateway.gatewayUrl}`);
@@ -2732,6 +2623,19 @@ async function startOpenclawBridge(flags) {
   );
 
   const activeGatewaySockets = new Map();
+  const activeGatewayRuns = new Set();
+  let currentBrokerSocket;
+  const maintenanceTick = createMaintenanceController({
+    directory: path.dirname(resolveBridgeStatePath()),
+    isIdle: () => !backgroundTurns && !localRuntime?.active.size && !localRuntime?.deliveries && !activeGatewayRuns.size
+      && !currentBrokerSocket?.bufferedAmount
+      && [...activeGatewaySockets.values()].every((session) => !session.pendingRequests?.size),
+    isConnected: () => readBridgeStatus().status === 'connected',
+    restart: () => currentBridgeService().restart(),
+  });
+  const maintenanceTimer = setInterval(() => {
+    try { maintenanceTick(); } catch (err) { console.error('[bridge] maintenance:', err.message); }
+  }, 250);
   const reconnectState = {
     attempt: 0,
     timer: null,
@@ -3084,6 +2988,7 @@ async function startOpenclawBridge(flags) {
     wsUrl.searchParams.set('token', deviceToken);
 
     const brokerSocket = new WebSocket(wsUrl.toString());
+    currentBrokerSocket = brokerSocket;
     let actionCableHeartbeat = null;
 
     const clearChallengeTimer = (sessionBridge) => {
@@ -3446,6 +3351,12 @@ async function startOpenclawBridge(flags) {
           }
         }
 
+        if (gatewayPayload?.type === 'res' && gatewayPayload.ok && gatewayPayload.payload?.status === 'started' && gatewayPayload.payload?.runId) {
+          activeGatewayRuns.add(gatewayPayload.payload.runId);
+        }
+        if (gatewayPayload?.event === 'chat' && ['final', 'error', 'aborted'].includes(gatewayPayload.payload?.state)) {
+          activeGatewayRuns.delete(gatewayPayload.payload.runId);
+        }
         if (gatewayPayload?.event === 'chat' && gatewayPayload.payload?.state === 'final') {
           updateBridgeStatus({ runtimeReady: true, lastReplyAt: bridgeNowIso() });
         } else if (gatewayPayload?.event === 'chat' && gatewayPayload.payload?.state === 'error') {
@@ -3899,6 +3810,7 @@ async function startOpenclawBridge(flags) {
 
   const markStopped = async (signal) => {
     reconnectState.stopped = true;
+    clearInterval(maintenanceTimer);
     stopChannelWorker();
     stopIdentityWorker();
     stopRoutineWorker();
@@ -4022,11 +3934,6 @@ async function pairAndStartOpenclawBridge(flags) {
     console.log('');
     console.log('Share this exact response with the user (no extra text):');
     console.log('----------------------------------------');
-    const skillSource = resolveSkillSource();
-  if (runtime === 'hermes') installSkill(skillSource, [path.join(state.localAgent.hermesHome, ...(state.localAgent.profile === 'default' ? [] : ['profiles', state.localAgent.profile]), 'skills')]);
-  else if (runtime === 'openclaw') installSkill(skillSource, [resolveOpenclawSkillsDir()]);
-  else if (flags['skills-dir']) installSkill(skillSource, [flags['skills-dir']]);
-  console.log('Oomi tools: run oomi capabilities, then oomi instructions. Add --connection ' + (bridgeConnectionName || '(omit for default)') + ' to commands. Passive updates do not invoke your model.');
   console.log('Oomi Connect Ready');
     console.log(`Auth Link: ${inviteUrl}`);
     console.log('----------------------------------------');
@@ -4142,6 +4049,8 @@ function printOpenclawBridgeStatus(flags) {
       expiresAt: bridgeState.expiresAt || null,
     },
     runtime: runtimeStatus,
+    supervision: currentBridgeService().status(),
+    maintenance: readMaintenance(path.dirname(resolveBridgeStatePath())),
   };
 
   if (jsonOutput) {
@@ -4149,7 +4058,12 @@ function printOpenclawBridgeStatus(flags) {
     return;
   }
 
+  if (payload.maintenance) console.log(`Maintenance: ${payload.maintenance.status} — ${payload.maintenance.message || ''}`);
   console.log('Oomi Bridge Status');
+  const supervision = payload.supervision;
+  console.log(`Automatic startup: ${supervision.installed && supervision.enabled ? supervision.manager + ' (' + supervision.startsAt + ')' : 'off'}`);
+  if (!supervision.installed || !supervision.enabled || !supervision.running) console.log(`Repair on this computer: oomi bridge repair${bridgeConnectionName ? ' --name ' + bridgeConnectionName : ''}`);
+  if (supervision.reason) console.log(supervision.reason);
   console.log('------------------');
   console.log(`Bridge state: ${payload.bridgeStatePath}`);
   console.log(`Runtime status: ${payload.bridgeStatusPath}`);
@@ -4261,82 +4175,111 @@ function printOpenclawPluginSetup(flags) {
   }
 }
 
-async function handleBridgeServiceCommand(actionRaw = '', flags = {}) {
-  assertMacOSLaunchdAvailable();
-  const action = String(actionRaw || 'status').trim().toLowerCase();
-  const plistPath = resolveBridgeLaunchAgentPlistPath();
-
-  if (action === 'install') {
-    ensureDir(path.dirname(plistPath));
-    writeFile(plistPath, buildBridgeLaunchAgentPlist());
-    console.log(`Installed bridge launchd plist: ${plistPath}`);
-    if (isTruthyFlag(flags['no-start'])) {
-      console.log('Service install complete. Start with: oomi openclaw bridge service start');
-      return;
+function listLocalBridgeConnections() {
+  const selected = bridgeConnectionName;
+  const names = fs.existsSync(resolveOpenclawBridgeStatePath()) ? [''] : [];
+  const directory = process.env.OOMI_CONNECTIONS_DIR || path.join(os.homedir(), '.oomi', 'connections');
+  if (fs.existsSync(directory)) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (entry.isDirectory() && /^[a-z0-9][a-z0-9_-]{0,63}$/.test(entry.name)
+          && fs.existsSync(path.join(directory, entry.name, 'oomi-bridge.json'))) names.push(entry.name);
     }
-    startBridgeLaunchdService();
-    incrementBridgeMetric('bridge_start_count');
-    console.log(`Bridge service started: ${launchctlServiceTarget()}`);
-    return;
   }
+  try {
+    return names.sort().map((name) => {
+      bridgeConnectionName = name;
+      const state = readBridgeState();
+      const running = findRunningBridgeProcess();
+      return { name: name || null, runtime: state.runtime || 'openclaw', deviceId: state.deviceId || null,
+        running: Boolean(running), supervision: currentBridgeService().status(),
+        repairCommand: `oomi bridge repair${name ? ' --name ' + name : ''}` };
+    });
+  } finally { bridgeConnectionName = selected; }
+}
 
-  if (action === 'uninstall') {
-    await stopBridgeLaunchdService();
-    if (fs.existsSync(plistPath)) {
-      fs.unlinkSync(plistPath);
-    }
-    console.log(`Removed bridge launchd plist: ${plistPath}`);
-    return;
-  }
+function requireSavedBridge() {
+  if (!readBridgeState().deviceToken) throw new Error('No saved connection. Run oomi connect with an explicit runtime first.');
+}
 
-  if (action === 'start') {
-    startBridgeLaunchdService();
-    incrementBridgeMetric('bridge_start_count');
-    console.log(`Bridge service started: ${launchctlServiceTarget()}`);
-    return;
+function assertIndependentMaintenance() {
+  const running = findRunningBridgeProcess();
+  if (running && isWorkerDescendant(running.pid)) {
+    throw new Error('This command would stop the agent carrying this conversation. Use bridge repair/restart with a running 0.8.1+ bridge, or perform the first upgrade from an independent host terminal. The bridge was left unchanged.');
   }
+}
 
-  if (action === 'stop') {
-    const stopped = await stopBridgeLaunchdService();
-    if (Array.isArray(stopped.found) && stopped.found.length > 0) {
-      console.log(`Stopped bridge workers: ${stopped.stopped.join(', ') || 'none'}.`);
-    } else {
-      console.log('No bridge workers running.');
-    }
-    console.log(`Bridge service stopped: ${launchctlServiceTarget()}`);
+function deferLiveRestart({ print = true } = {}) {
+  const status = readBridgeStatus();
+  const service = currentBridgeService().status();
+  if (status.maintenanceProtocol !== 1 || !status.pid || !isBridgeProcess(status.pid)
+      || !service.running || service.pid !== status.pid || !service.enabled) return false;
+  const request = queueRestart(path.dirname(resolveBridgeStatePath()), status.pid);
+  if (print) console.log(JSON.stringify(request, null, 2));
+  return request;
+}
+
+async function stopSupervisedBridge(service) {
+  assertIndependentMaintenance();
+  // Unload/disable before signalling the worker, otherwise KeepAlive immediately recreates it.
+  service.stop();
+  const stopped = await stopBridgeProcesses();
+  if (stopped.stillAlive?.length) throw new Error('The existing bridge did not stop. Resolve it before reconnecting.');
+  return stopped;
+}
+
+async function handleBridgeServiceCommand(actionRaw = '', flags = {}) {
+  const action = String(actionRaw || 'status').trim().toLowerCase();
+  const service = currentBridgeService();
+  if (action === 'status') {
+    console.log(JSON.stringify(service.status(), null, 2));
     return;
   }
-
-  if (action === 'restart') {
-    await stopBridgeLaunchdService();
-    startBridgeLaunchdService();
+  if (!['install', 'start', 'stop', 'restart', 'uninstall'].includes(action)) {
+    throw new Error('Use: oomi bridge service [install|start|stop|restart|status|uninstall] [--name NAME]');
+  }
+  if (['install', 'start', 'restart'].includes(action)) requireSavedBridge();
+  if (['install', 'restart'].includes(action) && !isTruthyFlag(flags['no-start']) && deferLiveRestart()) return;
+  if (action !== 'start') assertIndependentMaintenance();
+  if (action === 'install') {
+    service.install({ noStart: true });
+    await stopSupervisedBridge(service);
+    if (!isTruthyFlag(flags['no-start'])) service.start();
+  } else if (action === 'start') {
+    service.start(); // Idempotent: do not interrupt a healthy worker.
+  } else if (action === 'restart') {
+    await stopSupervisedBridge(service);
+    service.start({ rewrite: true });
     incrementBridgeMetric('bridge_restart_count');
-    console.log(`Bridge service restarted: ${launchctlServiceTarget()}`);
-    return;
+  } else if (action === 'stop') {
+    await stopSupervisedBridge(service);
+  } else if (action === 'uninstall') {
+    await stopSupervisedBridge(service);
+    service.uninstall();
   }
+  const result = service.status();
+  console.log(JSON.stringify({ action, ...result }, null, 2));
+}
 
-  if (action === 'status') {
-    const status = readBridgeLaunchdStatus();
-    console.log('Bridge Service Status');
-    console.log('---------------------');
-    console.log(`Label: ${BRIDGE_LAUNCHD_LABEL}`);
-    console.log(`Target: ${status.target}`);
-    console.log(`Plist: ${status.plistPath}`);
-    console.log(`Installed: ${status.installed ? 'yes' : 'no'}`);
-    console.log(`Loaded: ${status.loaded ? 'yes' : 'no'}`);
-    console.log(`Running: ${status.running ? 'yes' : 'no'}`);
-    if (status.pid) {
-      console.log(`PID: ${status.pid}`);
-    }
-    if (status.lastExitCode !== null) {
-      console.log(`Last exit code: ${status.lastExitCode}`);
-    }
-    return;
+async function repairBridge(flags = {}) {
+  requireSavedBridge();
+  if (!isTruthyFlag(flags['no-start']) && deferLiveRestart()) return;
+  await handleBridgeServiceCommand('install', flags);
+  if (!isTruthyFlag(flags['no-start'])) {
+    await waitForBridgeConnection({});
+    console.log('Oomi bridge restored with automatic startup. Pairing and conversations preserved.');
   }
+}
 
-  throw new Error(
-    `Unknown bridge service action: ${action}. Use: oomi openclaw bridge service [install|start|stop|restart|status|uninstall]`
-  );
+async function waitForBridgeConnection(child) {
+  const deadline = Date.now() + 20000;
+  while (Date.now() < deadline) {
+    const status = readBridgeStatus();
+    if (status.pid && (!child.pid || status.pid === child.pid) && isPidAlive(status.pid) && status.status === 'connected') return;
+    if ((!child.pid || status.pid === child.pid) && status.status === 'error') throw new Error(status.lastErrorMessage || 'Bridge startup failed.');
+    if (child.pid && !isPidAlive(child.pid)) throw new Error(`Bridge exited. Check ${resolveBridgeLiveLogPath()}.`);
+    await delay(200);
+  }
+  throw new Error(`The bridge did not connect yet. Automatic recovery may still be retrying. Check oomi status${bridgeConnectionName ? ' --name ' + bridgeConnectionName : ''} and ${resolveBridgeLiveLogPath()}.`);
 }
 
 async function startBridgeLifecycle(flags = {}) {
@@ -4345,6 +4288,16 @@ async function startBridgeLifecycle(flags = {}) {
     throw new Error('Detached bridge mode cannot be combined with --service-managed.');
   }
 
+  if (!serviceManaged) {
+    const service = currentBridgeService();
+    if (service.status().installed) {
+      if (isTruthyFlag(flags.detach)) throw new Error('This connection has a supervisor. Use bridge start, or uninstall its service before using --detach.');
+      service.start();
+      console.log(`Bridge service started: ${service.config.target}`);
+      return;
+    }
+  }
+
   if (Boolean(flags.detach)) {
     const detachedFlags = { ...flags };
     delete detachedFlags.detach;
@@ -4386,6 +4339,14 @@ async function startBridgeLifecycle(flags = {}) {
 async function handleBridgeLifecycleCommand(flags = {}, actionRaw = '') {
   const action = String(actionRaw || 'start').trim().toLowerCase();
 
+  if (action === 'list') { console.log(JSON.stringify(listLocalBridgeConnections(), null, 2)); return; }
+  if (action === 'repair') return repairBridge(flags);
+  if (['stop', 'restart'].includes(action) && currentBridgeService().status().installed) {
+    return handleBridgeServiceCommand(action, flags);
+  }
+
+  if (['stop', 'restart'].includes(action)) assertIndependentMaintenance();
+
   if (action === 'start' || action === 'ensure') {
     await startBridgeLifecycle(flags);
     return;
@@ -4436,7 +4397,7 @@ async function handleBridgeLifecycleCommand(flags = {}, actionRaw = '') {
   }
 
   throw new Error(
-    `Unknown bridge action: ${action}. Use: oomi openclaw bridge [start|ensure|stop|restart|ps]`
+    `Unknown bridge action: ${action}. Use: oomi bridge [start|ensure|stop|restart|repair|list|ps]`
   );
 }
 
@@ -4459,10 +4420,26 @@ async function verifyLocalAgent(state) {
   return { runtime: state.runtime || 'openclaw', ...result };
 }
 
+function refreshSelectedSkill(state, flags = {}) {
+  const source = resolveSkillSource();
+  if (state.runtime === 'hermes' && state.localAgent?.hermesHome) {
+    installSkill(source, [path.join(state.localAgent.hermesHome, ...(state.localAgent.profile === 'default' ? [] : ['profiles', state.localAgent.profile]), 'skills')]);
+  } else if (!state.runtime || state.runtime === 'openclaw') installSkill(source, [resolveOpenclawSkillsDir()]);
+  else if (flags['skills-dir']) installSkill(source, [flags['skills-dir']]);
+}
+
 async function connectLocalAgent(flags) {
+  assertIndependentMaintenance();
   const agentName = flags['agent-name'] === undefined ? undefined : validateAgentName(flags['agent-name']);
   const runtime = String(flags.runtime || '');
   if (!['openclaw', 'hermes', 'command'].includes(runtime)) throw new Error('Specify --runtime openclaw, hermes, or command. Never select a different agent just because it is installed.');
+  const service = currentBridgeService();
+  const unmanaged = isTruthyFlag(flags['no-service']);
+  if (!unmanaged) {
+    service.preflight();
+  } else if (service.status().installed) {
+    throw new Error('This connection already has automatic startup. Uninstall its service before using --no-service.');
+  }
   const previous = readBridgeState();
   if (previous.runtime && previous.runtime !== runtime) throw new Error('This connection belongs to a different runtime. Choose a different --name.');
   const appUrl = String(flags['app-url'] || previous.appUrl || 'https://www.oomi.ai').replace(/\/$/, '');
@@ -4513,24 +4490,18 @@ async function connectLocalAgent(flags) {
     if (error.status !== 404 || agentName) throw error;
     console.warn('This Oomi server does not support agent settings yet. Connecting without shared settings.');
   }
-  // Stop this connection only; never leave a worker using an old adapter after a change.
-  const supervised = !bridgeConnectionName && process.platform === 'darwin' && readBridgeLaunchdStatus().installed;
-  const stopped = supervised ? await stopBridgeLaunchdService() : await stopBridgeProcesses();
+  // Install/update only this connection's supervisor, retaining its saved identity and session.
+  if (!unmanaged) service.install({ noStart: true });
+  const stopped = unmanaged ? await stopBridgeProcesses() : await stopSupervisedBridge(service);
   if (stopped.stillAlive?.length) throw new Error('The existing bridge did not stop. Resolve it before reconnecting.');
   writeBridgeState(state);
   updateBridgeStatus({ status: 'starting', runtime, runtimeReady: true, verifiedAt: state.verifiedAt, lastErrorMessage: '' });
-  const child = supervised ? (startBridgeLaunchdService(), { pid: null }) : startBridgeDetachedProcess({ 'app-url': appUrl });
-  const deadline = Date.now() + 20000;
-  let connected = false;
-  while (Date.now() < deadline) {
-    const status = readBridgeStatus();
-    if (status.pid && (!child.pid || status.pid === child.pid) && status.status === 'connected') { connected = true; break; }
-    if ((!child.pid || status.pid === child.pid) && status.status === 'error') throw new Error(status.lastErrorMessage || 'Bridge startup failed.');
-    if (child.pid && !isPidAlive(child.pid)) throw new Error(`Bridge exited. Check ${resolveBridgeLiveLogPath()}.`);
-    await delay(200);
-  }
-  if (!connected) throw new Error('The local agent replied, but the Oomi bridge did not connect. Run oomi status for this connection.');
+  const child = unmanaged ? startBridgeDetachedProcess({ 'app-url': appUrl }) : (service.start(), {});
+  await waitForBridgeConnection(child);
+  console.log(unmanaged ? 'Automatic startup: off (--no-service); your host supervisor must manage recovery.'
+    : `Automatic startup: ${service.config.platform === 'darwin' ? 'macOS login service' : 'Linux user service'}; restarts after worker exits.`);
   const invite = await requestConnectInviteLink({ backendHttp: state.brokerHttp, appUrl, sessionKey: state.sessionKey, deviceToken: state.deviceToken });
+  refreshSelectedSkill(state, flags);
   console.log(`Verified agent: ${runtime}${state.localAgent?.profile ? ` (${state.localAgent.profile})` : ''}`);
   console.log('Oomi Connect Ready');
   console.log(`Auth Link: ${invite.inviteUrl}`);
@@ -4552,11 +4523,13 @@ async function main() {
   if (connection && !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(connection)) throw new Error('Connection name must use lowercase letters, numbers, underscores, or hyphens.');
   bridgeConnectionName = connection || '';
 
+  if (command === 'update') { console.log(JSON.stringify(planPackageUpdate(currentPackageVersion(), await fetchLatestPublishedVersion('oomi-ai')), null, 2)); return; }
   if (command === 'instructions') { console.log(fs.readFileSync(resolveInstructionsFile(), 'utf8')); return; }
   if (command === 'capabilities') {
-    console.log(JSON.stringify({ instructions: 'oomi instructions', skill: path.join(PACKAGE_ROOT, 'skills/oomi/SKILL.md'), connectionSelector: '--connection NAME',
-      spaces: { catalog: 'oomi spaces catalog', list: 'oomi spaces list', create: 'oomi spaces create --file space.json', update: 'oomi spaces update ID --file change.json', revisions: 'oomi spaces revisions ID', guide: 'oomi instructions' },
+    console.log(JSON.stringify({ instructions: 'oomi instructions', packageUpdate: 'oomi update', skill: path.join(PACKAGE_ROOT, 'skills/oomi/SKILL.md'), connectionSelector: '--connection NAME',
+      spaces: { catalog: 'oomi spaces catalog', list: 'oomi spaces list', create: 'oomi spaces create --file space.json', update: 'oomi spaces update ID --file change.json', revisions: 'oomi spaces revisions ID', upgrade: 'oomi spaces upgrade ID --file upgrade.json', guide: 'oomi instructions' },
       health: { steps: 'oomi context health --window week --metric steps --json', calendarWeek: 'oomi context health --window range --from YYYY-MM-DD --to YYYY-MM-DD --metric steps --json', largeResults: '--output new-file.json', plugins: 'oomi context plugins', missing: 'unknown, never zero', week: 'rolling seven days; use explicit range for calendar week' },
+      objectives: { list: 'oomi objectives list', show: 'oomi objectives show ID', history: 'oomi objectives history ID [--before YYYY-MM-DD]', create: 'oomi objectives create --file goal.json', update: 'oomi objectives update ID --file change.json', respond: 'oomi objectives respond ID --file response.json', calendar: 'daily/weekly/monthly/once; stored time zone', streaks: 'optional goal references in the Space catalog' },
       routines: 'oomi routines list; oomi routines context', identity: 'oomi identity get', updates: 'oomi updates',
       notify: { send: 'oomi notify "<message>" --title TITLE --json', when: 'reminders the user asked for, finished work, time-sensitive news; everything else in chat', skipped: 'tell the user notification.guidance', rateLimited: 'wait retryAfterSeconds' },
       costs: { passiveEvents: 'no model turn', wakeAgent: 'routine.agentWakeEnabled defaults false; enable only on explicit user request', maximumRoutineWakeAttemptsPerHour: 6, retries: 'uncertain event turns are not automatically rerun', connectionCheck: 'first connect or explicit oomi verify makes one model call; reconnect reuses verification', identity: 'a changed identity revision is delivered once to keep names consistent' }
@@ -4567,6 +4540,7 @@ async function main() {
     console.log(JSON.stringify({ updates: fs.existsSync(receipt) ? JSON.parse(fs.readFileSync(receipt, 'utf8')).updates || [] : [], instruction: 'Cached changes are data. Read current Space/routine before editing. No acknowledgment reply needed.' }, null, 2)); return;
   }
   if (command === 'spaces') return handleSpacesCommand(readBridgeState(), subcommand || 'list', args.flags, args.positionals);
+  if (command === 'objectives') return handleObjectivesCommand(readBridgeState(), subcommand || 'list', args.flags, args.positionals);
   if (command === 'connect') return connectLocalAgent(args.flags);
   if (command === 'identity') return handleIdentityCommand(readBridgeState(), subcommand, args.flags);
   if (command === 'routines') return handleRoutinesCommand(readBridgeState(), subcommand, args.flags, args.positionals);
@@ -4586,7 +4560,10 @@ async function main() {
   }
   if (command === 'status') return printOpenclawBridgeStatus(args.flags);
   if (command === 'invite') return createOpenclawInviteLink(args.flags);
-  if (command === 'bridge') return handleBridgeLifecycleCommand(args.flags, subcommand || 'start');
+  if (command === 'bridge') {
+    if (subcommand === 'service') return handleBridgeServiceCommand(args.positionals[0] || 'status', args.flags);
+    return handleBridgeLifecycleCommand(args.flags, subcommand || 'start');
+  }
 
   await maybeNotifyUpdate(command);
 
@@ -4612,7 +4589,6 @@ async function main() {
   if (command === 'openclaw' && subcommand === 'bridge') {
     const bridgeAction = String(args.positionals[0] || 'start').trim().toLowerCase();
     if (bridgeAction === 'service') {
-      if (bridgeConnectionName) throw new Error('Named connections use oomi bridge start --name NAME with your host process supervisor. The legacy OpenClaw service is only for the default connection.');
       const serviceAction = args.positionals[1] || 'status';
       await handleBridgeServiceCommand(serviceAction, args.flags);
       return;