@ericsanchezok/meta-synergy 1.1.26 → 1.2.18

package/src/service.ts

@@ -3,38 +3,37 @@ import { closeSync, openSync } from "node:fs"
 import { MetaSynergyControlClient } from "./control/client"
 import type { MetaSynergyLogsPayload, MetaSynergyServiceSnapshot } from "./control/schema"
 import { Platform } from "./platform"
-import { MetaSynergyStore } from "./state/store"
+import { MetaSynergyStore, type MetaSynergyState } from "./state/store"
 import { MetaSynergyLocalService } from "./service/local"
 
+interface MetaSynergyLaunchContext {
+  launcherPath: string
+  invocationEntry?: string
+  printLogs?: boolean
+}
+
+interface PersistedServiceStateUpdate {
+  desiredState?: MetaSynergyState["service"]["desiredState"]
+  runtimeStatus?: MetaSynergyState["service"]["runtimeStatus"]
+  pid?: number
+  printLogs?: boolean
+  startedAt?: number
+  stoppedAt?: number
+  lastExitAt?: number
+  logPath?: string
+}
+
 export namespace MetaSynergyService {
   export async function status(): Promise<MetaSynergyServiceSnapshot> {
     if (await MetaSynergyControlClient.isAvailable()) {
       return await MetaSynergyControlClient.request({ action: "service.status" })
     }
 
-    const state = await MetaSynergyStore.loadState()
-    const running = Boolean(state.service.pid && MetaSynergyLocalService.isPidRunning(state.service.pid))
-    if (state.service.runtimeStatus !== (running ? "running" : "stopped") || (state.service.pid && !running)) {
-      state.service.runtimeStatus = running ? "running" : "stopped"
-      if (!running) {
-        state.service.pid = undefined
-      }
-      await MetaSynergyStore.saveState(state)
-    }
-    return {
-      desiredState: state.service.desiredState,
-      runtimeStatus: state.service.runtimeStatus,
-      running,
-      pid: state.service.pid,
-      startedAt: state.service.startedAt,
-      stoppedAt: state.service.stoppedAt,
-      lastExitAt: state.service.lastExitAt,
-      printLogs: state.service.printLogs,
-      logPath: state.logs.filePath || MetaSynergyStore.logsPath(),
-    }
+    const { state, running } = await loadReconciledState()
+    return snapshotFromState(state, running)
   }
 
-  export async function start(input: { execPath: string; argv1?: string; printLogs?: boolean }) {
+  export async function start(input: MetaSynergyLaunchContext) {
     if (await MetaSynergyControlClient.isAvailable()) {
       return {
         changed: false,
@@ -43,12 +42,12 @@ export namespace MetaSynergyService {
       }
     }
 
-    const state = await MetaSynergyStore.loadState()
-    const currentRunning = Boolean(state.service.pid && MetaSynergyLocalService.isPidRunning(state.service.pid))
+    const { state, running: currentRunning } = await loadReconciledState()
     if (currentRunning) {
-      state.service.desiredState = "running"
-      state.service.runtimeStatus = "running"
-      await MetaSynergyStore.saveState(state)
+      await updatePersistedServiceState({
+        desiredState: "running",
+        runtimeStatus: "running",
+      })
       return {
         changed: false,
         alreadyRunning: true,
@@ -60,13 +59,14 @@ export namespace MetaSynergyService {
     await MetaSynergyLocalService.removeSocketFile(MetaSynergyStore.controlSocketPath())
     const outputPath = MetaSynergyStore.logsPath()
     const stdout = openSync(outputPath, "a")
-    const command = resolveServiceCommand(input)
+    const command = resolveServerLaunchCommand(input)
 
-    state.service.desiredState = "running"
-    state.service.runtimeStatus = "starting"
-    state.service.printLogs = input.printLogs ?? false
-    state.logs.filePath = outputPath
-    await MetaSynergyStore.saveState(state)
+    await updatePersistedServiceState({
+      desiredState: "running",
+      runtimeStatus: "starting",
+      printLogs: input.printLogs ?? false,
+      logPath: outputPath,
+    })
 
     try {
       const child = spawn(command.file, command.args, {
@@ -76,19 +76,19 @@ export namespace MetaSynergyService {
       })
       child.unref()
       await waitForControlPlane(2_500)
-      const running = await MetaSynergyControlClient.isAvailable()
-      const nextState = await MetaSynergyStore.loadState()
-      nextState.service.desiredState = running ? "running" : "stopped"
-      nextState.service.runtimeStatus = running ? "running" : "stopped"
-      nextState.service.pid = running ? child.pid : undefined
-      nextState.service.startedAt = running ? Date.now() : nextState.service.startedAt
-      nextState.service.stoppedAt = running ? undefined : Date.now()
-      nextState.service.lastExitAt = running ? nextState.service.lastExitAt : Date.now()
-      nextState.service.printLogs = input.printLogs ?? false
-      nextState.logs.filePath = outputPath
-      await MetaSynergyStore.saveState(nextState)
+      const controlPlaneReady = await MetaSynergyControlClient.isAvailable()
+      await updatePersistedServiceState((currentState) => ({
+        desiredState: controlPlaneReady ? "running" : "stopped",
+        runtimeStatus: controlPlaneReady ? "running" : "stopped",
+        pid: controlPlaneReady ? child.pid : undefined,
+        startedAt: controlPlaneReady ? Date.now() : currentState.service.startedAt,
+        stoppedAt: controlPlaneReady ? undefined : Date.now(),
+        lastExitAt: controlPlaneReady ? currentState.service.lastExitAt : Date.now(),
+        printLogs: input.printLogs ?? false,
+        logPath: outputPath,
+      }))
       return {
-        changed: running,
+        changed: controlPlaneReady,
         alreadyRunning: false,
         ...(await status()),
       }
@@ -102,13 +102,14 @@ export namespace MetaSynergyService {
       const snapshot = await status()
       await MetaSynergyControlClient.request({ action: "service.stop" }).catch(() => undefined)
       await waitForControlPlaneShutdown(2_500)
-      const state = await MetaSynergyStore.loadState()
-      state.service.desiredState = "stopped"
-      state.service.runtimeStatus = "stopped"
-      state.service.pid = undefined
-      state.service.stoppedAt = Date.now()
-      state.service.lastExitAt = state.service.stoppedAt
-      await MetaSynergyStore.saveState(state)
+      const stoppedAt = Date.now()
+      await updatePersistedServiceState({
+        desiredState: "stopped",
+        runtimeStatus: "stopped",
+        pid: undefined,
+        stoppedAt,
+        lastExitAt: stoppedAt,
+      })
       return {
         changed: snapshot.running,
         alreadyStopped: !snapshot.running,
@@ -116,19 +117,20 @@ export namespace MetaSynergyService {
       }
     }
 
-    const state = await MetaSynergyStore.loadState()
+    const { state, running } = await loadReconciledState()
     const pid = state.service.pid
-    const running = Boolean(pid && MetaSynergyLocalService.isPidRunning(pid))
 
-    state.service.desiredState = "stopped"
-    state.service.runtimeStatus = running ? "stopping" : "stopped"
-    await MetaSynergyStore.saveState(state)
+    await updatePersistedServiceState({
+      desiredState: "stopped",
+      runtimeStatus: running ? "stopping" : "stopped",
+    })
 
     if (!pid || !running) {
-      state.service.pid = undefined
-      state.service.runtimeStatus = "stopped"
-      state.service.stoppedAt = Date.now()
-      await MetaSynergyStore.saveState(state)
+      await updatePersistedServiceState({
+        pid: undefined,
+        runtimeStatus: "stopped",
+        stoppedAt: Date.now(),
+      })
       return {
         changed: false,
         alreadyStopped: true,
@@ -138,13 +140,14 @@ export namespace MetaSynergyService {
 
     await MetaSynergyLocalService.terminatePid(pid)
     await MetaSynergyLocalService.removeSocketFile(MetaSynergyStore.controlSocketPath())
-    const nextState = await MetaSynergyStore.loadState()
-    nextState.service.desiredState = "stopped"
-    nextState.service.runtimeStatus = "stopped"
-    nextState.service.pid = undefined
-    nextState.service.stoppedAt = Date.now()
-    nextState.service.lastExitAt = nextState.service.stoppedAt
-    await MetaSynergyStore.saveState(nextState)
+    const stoppedAt = Date.now()
+    await updatePersistedServiceState({
+      desiredState: "stopped",
+      runtimeStatus: "stopped",
+      pid: undefined,
+      stoppedAt,
+      lastExitAt: stoppedAt,
+    })
     return {
       changed: true,
       alreadyStopped: false,
@@ -152,7 +155,7 @@ export namespace MetaSynergyService {
     }
   }
 
-  export async function restart(input: { execPath: string; argv1?: string; printLogs?: boolean }) {
+  export async function restart(input: MetaSynergyLaunchContext) {
     const stopped = await stop()
     const started = await start(input)
     return { stopped, started }
@@ -192,16 +195,105 @@ export namespace MetaSynergyService {
   }
 }
 
-function resolveServiceCommand(input: { execPath: string; argv1?: string; printLogs?: boolean }) {
-  if (!input.argv1 || input.argv1 === input.execPath) {
-    const args = ["server"]
-    if (input.printLogs) args.push("--print-logs")
-    return { file: input.execPath, args }
+function resolveServerLaunchCommand(input: MetaSynergyLaunchContext) {
+  const serverArgs = ["server"]
+  if (input.printLogs) serverArgs.push("--print-logs")
+
+  const invocationEntry = input.invocationEntry
+  if (!invocationEntry || invocationEntry === input.launcherPath) {
+    return { file: input.launcherPath, args: serverArgs }
+  }
+
+  const isBunVirtualEntrypoint = invocationEntry.startsWith("/$bunfs/") || invocationEntry.endsWith("/cli.js")
+  if (isBunVirtualEntrypoint) {
+    return { file: input.launcherPath, args: serverArgs }
+  }
+
+  return { file: input.launcherPath, args: [invocationEntry, ...serverArgs] }
+}
+
+function snapshotFromState(state: MetaSynergyState, running: boolean): MetaSynergyServiceSnapshot {
+  return {
+    desiredState: state.service.desiredState,
+    runtimeStatus: state.service.runtimeStatus,
+    running,
+    pid: state.service.pid,
+    startedAt: state.service.startedAt,
+    stoppedAt: state.service.stoppedAt,
+    lastExitAt: state.service.lastExitAt,
+    printLogs: state.service.printLogs,
+    logPath: state.logs.filePath || MetaSynergyStore.logsPath(),
+  }
+}
+
+async function loadReconciledState(): Promise<{ state: MetaSynergyState; running: boolean }> {
+  const state = await MetaSynergyStore.loadState()
+  const running = Boolean(state.service.pid && MetaSynergyLocalService.isPidRunning(state.service.pid))
+  if (reconcileObservedRuntimeState(state, running)) {
+    await MetaSynergyStore.saveState(state)
+  }
+  return { state, running }
+}
+
+async function updatePersistedServiceState(
+  update: PersistedServiceStateUpdate | ((state: MetaSynergyState) => PersistedServiceStateUpdate),
+): Promise<MetaSynergyState> {
+  const state = await MetaSynergyStore.loadState()
+  const nextUpdate = typeof update === "function" ? update(state) : update
+  if (applyPersistedServiceStateUpdate(state, nextUpdate)) {
+    await MetaSynergyStore.saveState(state)
+  }
+  return state
+}
+
+function reconcileObservedRuntimeState(state: MetaSynergyState, running: boolean): boolean {
+  const expectedRuntimeStatus = running ? "running" : "stopped"
+  return applyPersistedServiceStateUpdate(state, {
+    runtimeStatus:
+      state.service.runtimeStatus === expectedRuntimeStatus && !(state.service.pid && !running)
+        ? undefined
+        : expectedRuntimeStatus,
+    pid: state.service.pid && !running ? undefined : state.service.pid,
+  })
+}
+
+function applyPersistedServiceStateUpdate(state: MetaSynergyState, update: PersistedServiceStateUpdate): boolean {
+  let changed = false
+
+  if (update.desiredState !== undefined && state.service.desiredState !== update.desiredState) {
+    state.service.desiredState = update.desiredState
+    changed = true
+  }
+  if (update.runtimeStatus !== undefined && state.service.runtimeStatus !== update.runtimeStatus) {
+    state.service.runtimeStatus = update.runtimeStatus
+    changed = true
+  }
+  if (Object.hasOwn(update, "pid") && state.service.pid !== update.pid) {
+    state.service.pid = update.pid
+    changed = true
+  }
+  if (update.printLogs !== undefined && state.service.printLogs !== update.printLogs) {
+    state.service.printLogs = update.printLogs
+    changed = true
+  }
+  if (Object.hasOwn(update, "startedAt") && state.service.startedAt !== update.startedAt) {
+    state.service.startedAt = update.startedAt
+    changed = true
+  }
+  if (Object.hasOwn(update, "stoppedAt") && state.service.stoppedAt !== update.stoppedAt) {
+    state.service.stoppedAt = update.stoppedAt
+    changed = true
+  }
+  if (Object.hasOwn(update, "lastExitAt") && state.service.lastExitAt !== update.lastExitAt) {
+    state.service.lastExitAt = update.lastExitAt
+    changed = true
+  }
+  if (update.logPath !== undefined && state.logs.filePath !== update.logPath) {
+    state.logs.filePath = update.logPath
+    changed = true
   }
 
-  const args = [input.argv1, "server"]
-  if (input.printLogs) args.push("--print-logs")
-  return { file: input.execPath, args }
+  return changed
 }
 
 async function waitForControlPlane(timeoutMs: number) {

package/src/state/migration.ts

@@ -0,0 +1,19 @@
+import { readFile } from "node:fs/promises"
+import { MetaSynergyStore } from "./store"
+import type { MetaSynergyMigration } from "../migration/types"
+
+export namespace MetaSynergyStateMigrations {
+  export const migrations: MetaSynergyMigration[] = [
+    {
+      id: "20260408-normalize-state",
+      description: "Normalize persisted meta-synergy state",
+      async run() {
+        const raw = await readFile(MetaSynergyStore.statePath(), "utf8").catch(() => undefined)
+        if (!raw) return
+        const parsed = JSON.parse(raw) as unknown
+        const next = MetaSynergyStore.hydrateStateForMigration(parsed)
+        await MetaSynergyStore.saveState(next)
+      },
+    },
+  ]
+}

package/src/state/store.ts

@@ -2,10 +2,12 @@ import os from "node:os"
 import path from "node:path"
 import process from "node:process"
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises"
+import { MetaSynergyOwnerRegistry, type MetaSynergyOwnerRegistryState } from "../owner-registry"
 
 export type MetaSynergyApprovalMode = "auto" | "manual" | "trusted-only"
 export type MetaSynergyPendingRequestStatus = "pending" | "approved" | "denied"
 export type MetaSynergyConnectionStatus = "disconnected" | "connecting" | "connected"
+export type MetaSynergyRuntimeMode = "managed" | "standalone"
 export type MetaSynergyServiceDesiredState = "running" | "stopped"
 export type MetaSynergyServiceRuntimeStatus = "starting" | "running" | "stopping" | "stopped"
 
@@ -59,6 +61,8 @@ export interface MetaSynergyState {
   envID?: string
   hostSessionID?: string
   label?: string
+  runtimeMode: MetaSynergyRuntimeMode
+  ownerRegistry: MetaSynergyOwnerRegistryState
   collaborationEnabled: boolean
   approvalMode: MetaSynergyApprovalMode
   trusted: MetaSynergyTrustedIdentityState
@@ -72,6 +76,8 @@ export interface MetaSynergyState {
 }
 
 const DEFAULT_STATE: MetaSynergyState = {
+  runtimeMode: "standalone",
+  ownerRegistry: MetaSynergyOwnerRegistry.defaultRegistry(),
   collaborationEnabled: true,
   approvalMode: "manual",
   trusted: {
@@ -97,7 +103,7 @@ export namespace MetaSynergyStore {
     return process.env.META_SYNERGY_HOME || path.join(os.homedir(), ".meta-synergy")
   }
 
-  export function authPath(): string {
+  export function legacyAuthPath(): string {
     return path.join(root(), "auth.json")
   }
 
@@ -105,6 +111,14 @@ export namespace MetaSynergyStore {
     return path.join(root(), "state.json")
   }
 
+  export function migrationLogPath(): string {
+    return path.join(root(), "migrations.json")
+  }
+
+  export function ownerRegistryPath(): string {
+    return path.join(root(), "owner.json")
+  }
+
   export function logsPath(): string {
     return path.join(root(), "logs", "runtime.log")
   }
@@ -119,21 +133,21 @@ export namespace MetaSynergyStore {
     await mkdir(path.dirname(controlSocketPath()), { recursive: true })
   }
 
-  export async function loadAuth(): Promise<MetaSynergyAuthState | undefined> {
+  export async function loadLegacyAuth(): Promise<MetaSynergyAuthState | undefined> {
     try {
-      return JSON.parse(await readFile(authPath(), "utf8")) as MetaSynergyAuthState
+      return JSON.parse(await readFile(legacyAuthPath(), "utf8")) as MetaSynergyAuthState
     } catch {
       return undefined
     }
   }
 
-  export async function saveAuth(auth: MetaSynergyAuthState): Promise<void> {
+  export async function saveLegacyAuth(auth: MetaSynergyAuthState): Promise<void> {
     await ensureRoot()
-    await writeFile(authPath(), JSON.stringify(auth, null, 2) + "\n")
+    await writeFile(legacyAuthPath(), JSON.stringify(auth, null, 2) + "\n")
   }
 
-  export async function clearAuth(): Promise<void> {
-    await unlink(authPath()).catch(() => undefined)
+  export async function clearLegacyAuth(): Promise<void> {
+    await unlink(legacyAuthPath()).catch(() => undefined)
   }
 
   export async function loadState(): Promise<MetaSynergyState> {
@@ -149,6 +163,28 @@ export namespace MetaSynergyStore {
     await ensureRoot()
     await writeFile(statePath(), JSON.stringify(hydrateState(state), null, 2) + "\n")
   }
+
+  export async function loadMigrationLog(): Promise<Record<string, number>> {
+    try {
+      const parsed = JSON.parse(await readFile(migrationLogPath(), "utf8")) as Record<string, unknown>
+      return Object.fromEntries(
+        Object.entries(parsed).filter(
+          (entry): entry is [string, number] => typeof entry[0] === "string" && typeof entry[1] === "number",
+        ),
+      )
+    } catch {
+      return {}
+    }
+  }
+
+  export async function saveMigrationLog(log: Record<string, number>): Promise<void> {
+    await ensureRoot()
+    await writeFile(migrationLogPath(), JSON.stringify(log, null, 2) + "\n")
+  }
+
+  export function hydrateStateForMigration(parsed: unknown): MetaSynergyState {
+    return hydrateState(isPartialState(parsed) ? parsed : undefined)
+  }
 }
 
 function hydrateState(parsed: Partial<MetaSynergyState> | undefined): MetaSynergyState {
@@ -156,6 +192,8 @@ function hydrateState(parsed: Partial<MetaSynergyState> | undefined): MetaSynerg
     envID: parsed?.envID,
     hostSessionID: parsed?.hostSessionID,
     label: parsed?.label,
+    runtimeMode: parseRuntimeMode(parsed?.runtimeMode),
+    ownerRegistry: MetaSynergyOwnerRegistry.hydrate(parsed?.ownerRegistry),
     collaborationEnabled: parsed?.collaborationEnabled ?? DEFAULT_STATE.collaborationEnabled,
     approvalMode: parseApprovalMode(parsed?.approvalMode),
     trusted: {
@@ -235,6 +273,10 @@ function hydratePendingRequests(input: MetaSynergyState["pendingRequests"] | und
   return requests
 }
 
+function parseRuntimeMode(input: unknown): MetaSynergyRuntimeMode {
+  return input === "managed" || input === "standalone" ? input : DEFAULT_STATE.runtimeMode
+}
+
 function parseApprovalMode(input: unknown): MetaSynergyApprovalMode {
   return input === "auto" || input === "trusted-only" || input === "manual" ? input : DEFAULT_STATE.approvalMode
 }
@@ -268,3 +310,7 @@ function uniqueNumbers(values: number[] | undefined): number[] {
     ...new Set((values ?? []).filter((value): value is number => typeof value === "number" && Number.isFinite(value))),
   ]
 }
+
+function isPartialState(value: unknown): value is Partial<MetaSynergyState> {
+  return typeof value === "object" && value !== null
+}

package/src/types.ts

@@ -1,3 +1,4 @@
+import z from "zod"
 import type { MetaProtocolEnv, MetaProtocolHost } from "@ericsanchezok/meta-protocol"
 
 export type EnvID = MetaProtocolEnv.EnvID
@@ -10,6 +11,13 @@ export interface RemoteHostIdentity {
   label?: string
 }
 
+export const HolosCallerSchema = z.object({
+  type: z.string(),
+  agentID: z.string(),
+  ownerUserID: z.number(),
+  profile: z.record(z.string(), z.unknown()).optional(),
+})
+
 export interface HolosCaller {
   type: string
   agentID: string

package/test/cli-backend-auth.test.ts

@@ -0,0 +1,86 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { MetaSynergyCLIBackend } from "../src/cli-backend"
+import { MetaSynergyHolosAuth } from "../src/holos/auth"
+import { MetaSynergyStore } from "../src/state/store"
+
+const originalMetaHome = process.env.META_SYNERGY_HOME
+const originalSynergyHome = process.env.SYNERGY_TEST_HOME
+const originalFetch = globalThis.fetch
+const tempRoots: string[] = []
+
+beforeEach(async () => {
+  const metaRoot = await mkdtemp(path.join(os.tmpdir(), "meta-synergy-cli-auth-meta-"))
+  const synergyHome = await mkdtemp(path.join(os.tmpdir(), "meta-synergy-cli-auth-synergy-"))
+  tempRoots.push(metaRoot, synergyHome)
+  process.env.META_SYNERGY_HOME = metaRoot
+  process.env.SYNERGY_TEST_HOME = synergyHome
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify({ code: 0, data: { ws_token: "token", expires_in: 60 } }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    })) as typeof fetch
+})
+
+afterAll(async () => {
+  globalThis.fetch = originalFetch
+  if (originalMetaHome === undefined) delete process.env.META_SYNERGY_HOME
+  else process.env.META_SYNERGY_HOME = originalMetaHome
+
+  if (originalSynergyHome === undefined) delete process.env.SYNERGY_TEST_HOME
+  else process.env.SYNERGY_TEST_HOME = originalSynergyHome
+
+  await Promise.all(tempRoots.map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe("meta-synergy cli backend auth payloads", () => {
+  test("whoami reports shared auth source", async () => {
+    const sharedPath = MetaSynergyHolosAuth.sharedAuthPath()
+    await mkdir(path.dirname(sharedPath), { recursive: true })
+    await writeFile(
+      sharedPath,
+      JSON.stringify({ holos: { type: "holos", agentId: "agent_shared", agentSecret: "secret_shared" } }, null, 2),
+    )
+
+    const result = await MetaSynergyCLIBackend.whoami()
+    expect(result.auth).toEqual({
+      loggedIn: true,
+      agentID: "agent_shared",
+      source: "shared",
+    })
+  })
+
+  test("doctor reports migrated legacy auth source in payload and checks", async () => {
+    await MetaSynergyStore.saveLegacyAuth({ agentID: "agent_legacy", agentSecret: "secret_legacy" })
+
+    const result = await MetaSynergyCLIBackend.doctor()
+    expect(result.auth).toEqual({
+      loggedIn: true,
+      agentID: "agent_legacy",
+      source: "legacy-migrated",
+    })
+    expect(result.checks.find((check) => check.name === "auth")).toEqual({
+      name: "auth",
+      ok: true,
+      detail: "agent agent_legacy (legacy-migrated)",
+    })
+  })
+
+  test("logout clears auth and reports logged-out source state", async () => {
+    await MetaSynergyStore.saveLegacyAuth({ agentID: "agent_clear", agentSecret: "secret_clear" })
+    await MetaSynergyHolosAuth.save({ agentID: "agent_clear", agentSecret: "secret_clear" })
+
+    const result = await MetaSynergyCLIBackend.logout()
+    expect(result.authCleared).toBe(true)
+
+    const whoami = await MetaSynergyCLIBackend.whoami()
+    expect(whoami.auth).toEqual({
+      loggedIn: false,
+      agentID: null,
+      source: null,
+    })
+  })
+})

package/test/cli-backend-mode.test.ts

@@ -0,0 +1,49 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { MetaSynergyCLIBackend } from "../src/cli-backend"
+import { MetaSynergyStore } from "../src/state/store"
+
+const originalHome = process.env.META_SYNERGY_HOME
+const tempRoots: string[] = []
+
+beforeEach(async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "meta-synergy-cli-mode-"))
+  tempRoots.push(root)
+  process.env.META_SYNERGY_HOME = root
+})
+
+afterAll(async () => {
+  if (originalHome === undefined) {
+    delete process.env.META_SYNERGY_HOME
+  } else {
+    process.env.META_SYNERGY_HOME = originalHome
+  }
+  await Promise.all(tempRoots.map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe("meta-synergy cli backend mode transitions", () => {
+  test("standalone mode clears managed ownership when service is offline", async () => {
+    const state = await MetaSynergyStore.loadState()
+    state.runtimeMode = "managed"
+    state.ownerRegistry.local.ownerIDs = ["synergy:test"]
+    state.ownerRegistry.local.activeOwnerID = "synergy:test"
+    state.ownerRegistry.local.leaseExpiresAt = Date.now() + 10_000
+    await MetaSynergyStore.saveState(state)
+
+    const result = (await MetaSynergyCLIBackend.enterStandaloneMode()) as {
+      mode: string
+      ownership: { local: { owned: boolean } }
+      connectionStatus: string
+    }
+    expect(result.mode).toBe("standalone")
+    expect(result.ownership.local.owned).toBe(false)
+    expect(result.connectionStatus).toBe("disconnected")
+
+    const next = await MetaSynergyStore.loadState()
+    expect(next.runtimeMode).toBe("standalone")
+    expect(next.ownerRegistry.local.activeOwnerID).toBeUndefined()
+  })
+})