@narumitw/pi-sync 0.57.9 → 0.57.10

package/dist/chunks/{chunk-UOHR7LRO.ts → chunk-Z5O2TLNF.ts}

@@ -2,22 +2,23 @@
 // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
 import {
   encodeSnapshot
-} from "./chunk-UBV24CG4.ts";
+} from "./chunk-MRIPZGPR.ts";
 import {
   throwIfAborted
 } from "./chunk-PWMWOJP4.ts";
 import {
-  agentDir,
+  stateDir
+} from "./chunk-SWRVXVFD.ts";
+import {
   createSnapshot,
-  sessionDirFromContext,
   sessionSnapshotPathFromAbsolute
-} from "./chunk-QOFMXPM5.ts";
+} from "./chunk-PHANBTVM.ts";
 import {
-  stateDir
-} from "./chunk-SWRVXVFD.ts";
+  sessionDirFromContext
+} from "./chunk-DO55XUNU.ts";
 import {
   syncDirectory
-} from "./chunk-HUZ5CR4W.ts";
+} from "./chunk-AR2DGDUI.ts";
 
 // src/sync/sync-local.ts
 import fs from "node:fs/promises";
@@ -29,18 +30,6 @@ function protectedSessionPaths(ctx, sessionRoot = sessionDirFromContext(ctx)) {
   const snapshotPath = sessionFile ? sessionSnapshotPathFromAbsolute(sessionFile, sessionRoot) : void 0;
   return snapshotPath ? /* @__PURE__ */ new Set([snapshotPath]) : /* @__PURE__ */ new Set();
 }
-function captureMutationOwner(ctx, signal) {
-  const manager = ctx.sessionManager;
-  const file = manager.getSessionFile?.();
-  const id = manager.getSessionId?.();
-  const cwd = manager.getCwd?.();
-  const root = agentDir();
-  return () => {
-    throwIfAborted(signal);
-    if (ctx.sessionManager !== manager || manager.getSessionFile?.() !== file || manager.getSessionId?.() !== id || manager.getCwd?.() !== cwd || agentDir() !== root)
-      throw new Error("Session changed during file mutation; evidence retained for review.");
-  };
-}
 async function backupLocal(profile, options = {}, signal) {
   throwIfAborted(signal);
   const snapshot = await createSnapshot(profile, { ...options, signal });
@@ -64,7 +53,6 @@ async function backupLocal(profile, options = {}, signal) {
 
 export {
   protectedSessionPaths,
-  captureMutationOwner,
   backupLocal
 };
-//# sourceMappingURL=chunk-UOHR7LRO.ts.map
+//# sourceMappingURL=chunk-Z5O2TLNF.ts.map

package/dist/chunks/chunk-Z5O2TLNF.ts.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/sync/sync-local.ts"],
+  "sourcesContent": ["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { ExtensionCommandContext, ExtensionContext } from \"@earendil-works/pi-coding-agent\";\nimport { sessionDirFromContext } from \"../snapshot/session-paths.js\";\nimport { createSnapshot, sessionSnapshotPathFromAbsolute } from \"../snapshot/snapshot.js\";\nimport { encodeSnapshot } from \"../snapshot/snapshot-codec.js\";\nimport type { SnapshotOptions } from \"../snapshot/snapshot-types.js\";\nimport { syncDirectory } from \"../state/json-file.js\";\nimport { stateDir } from \"../state/state-directory.js\";\nimport { throwIfAborted } from \"./signals.js\";\n\nexport function protectedSessionPaths(\n  ctx: ExtensionCommandContext | ExtensionContext,\n  sessionRoot = sessionDirFromContext(ctx),\n) {\n  const getSessionFile = ctx.sessionManager.getSessionFile;\n  if (typeof getSessionFile !== \"function\") return new Set<string>();\n  const sessionFile = getSessionFile.call(ctx.sessionManager) as string | undefined;\n  const snapshotPath = sessionFile ? sessionSnapshotPathFromAbsolute(sessionFile, sessionRoot) : undefined;\n  return snapshotPath ? new Set([snapshotPath]) : new Set<string>();\n}\n\nexport { captureMutationOwner } from \"./mutation-owner.js\";\n\nexport async function backupLocal(profile: string, options: SnapshotOptions = {}, signal?: AbortSignal) {\n  throwIfAborted(signal);\n  const snapshot = await createSnapshot(profile, { ...options, signal });\n  throwIfAborted(signal);\n  const backupDirectory = path.join(stateDir(), \"backups\");\n  await fs.mkdir(backupDirectory, { recursive: true, mode: 0o700 });\n  throwIfAborted(signal);\n  const backupPath = path.join(backupDirectory, `${snapshot.id}.json.gz`);\n  const encoded = await encodeSnapshot(snapshot);\n  throwIfAborted(signal);\n  const handle = await fs.open(backupPath, \"wx\", 0o600);\n  try {\n    await handle.writeFile(encoded);\n    await handle.sync();\n  } finally {\n    await handle.close();\n  }\n  await syncDirectory(backupDirectory);\n  return backupPath;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AAUV,SAAS,sBACd,KACA,cAAc,sBAAsB,GAAG,GACvC;AACA,QAAM,iBAAiB,IAAI,eAAe;AAC1C,MAAI,OAAO,mBAAmB,WAAY,QAAO,oBAAI,IAAY;AACjE,QAAM,cAAc,eAAe,KAAK,IAAI,cAAc;AAC1D,QAAM,eAAe,cAAc,gCAAgC,aAAa,WAAW,IAAI;AAC/F,SAAO,eAAe,oBAAI,IAAI,CAAC,YAAY,CAAC,IAAI,oBAAI,IAAY;AAClE;AAIA,eAAsB,YAAY,SAAiB,UAA2B,CAAC,GAAG,QAAsB;AACtG,iBAAe,MAAM;AACrB,QAAM,WAAW,MAAM,eAAe,SAAS,EAAE,GAAG,SAAS,OAAO,CAAC;AACrE,iBAAe,MAAM;AACrB,QAAM,kBAAkB,KAAK,KAAK,SAAS,GAAG,SAAS;AACvD,QAAM,GAAG,MAAM,iBAAiB,EAAE,WAAW,MAAM,MAAM,IAAM,CAAC;AAChE,iBAAe,MAAM;AACrB,QAAM,aAAa,KAAK,KAAK,iBAAiB,GAAG,SAAS,EAAE,UAAU;AACtE,QAAM,UAAU,MAAM,eAAe,QAAQ;AAC7C,iBAAe,MAAM;AACrB,QAAM,SAAS,MAAM,GAAG,KAAK,YAAY,MAAM,GAAK;AACpD,MAAI;AACF,UAAM,OAAO,UAAU,OAAO;AAC9B,UAAM,OAAO,KAAK;AAAA,EACpB,UAAE;AACA,UAAM,OAAO,MAAM;AAAA,EACrB;AACA,QAAM,cAAc,eAAe;AACnC,SAAO;AACT;",
+  "names": []
+}

package/dist/chunks/command-handler-FO6F2APH.ts

@@ -0,0 +1,543 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  automaticSyncSummary
+} from "./chunk-ECYCNZOE.ts";
+import {
+  withAgentSyncLock
+} from "./chunk-ODF2M4RF.ts";
+import "./chunk-3ST7RSYN.ts";
+import {
+  syncErrorGuidance
+} from "./chunk-G4RUXRWZ.ts";
+import {
+  observationMatchesConfig,
+  syncAttentionMatchesConfig
+} from "./chunk-U77DWNRH.ts";
+import {
+  parseOptions,
+  resolveSyncCommand,
+  splitArgs,
+  startupTransferSummary,
+  usage,
+  validateCommandOptions
+} from "./chunk-NLWS55B6.ts";
+import {
+  safeTerminalText
+} from "./chunk-AMJRUXFT.ts";
+import {
+  setSyncStatus
+} from "./chunk-K3RIEL6J.ts";
+import {
+  SetupPullRequiresUiError,
+  errorMessage,
+  isSyncDecisionRequiredError
+} from "./chunk-7D5SF7P3.ts";
+import {
+  activeLocalConfigPath,
+  createLocalConfigDocument,
+  loadConfig,
+  localConfigPath,
+  localConfigTemplate,
+  readLocalConfigObject,
+  sessionTokenWarnings,
+  syncSessionsWarnings
+} from "./chunk-RX3WGWVL.ts";
+import "./chunk-X7R6DCVF.ts";
+import {
+  unlock,
+  withLock
+} from "./chunk-MDUORMCK.ts";
+import {
+  combineSignals,
+  throwIfAborted
+} from "./chunk-PWMWOJP4.ts";
+import {
+  readStateForConfig,
+  syncStateFingerprint
+} from "./chunk-73MDIVYJ.ts";
+import {
+  migrateLegacyStateDirectory,
+  stateDirectoryMigrationNotice
+} from "./chunk-SWRVXVFD.ts";
+import "./chunk-2JZFHNLM.ts";
+import "./chunk-T2SJD3N7.ts";
+import {
+  RemoteSelectionMismatchError,
+  formatRemoteSelectionMismatch
+} from "./chunk-DFJGTVPX.ts";
+import "./chunk-AR2DGDUI.ts";
+import "./chunk-YZ5BQNRZ.ts";
+import "./chunk-DT7M4VQS.ts";
+import "./chunk-YDVQYUHE.ts";
+import "./chunk-PRUEIIK7.ts";
+
+// src/ui/operation-dialogs.ts
+function trackOperationDialogs(ctx, onDialog) {
+  if (!onDialog) return ctx;
+  const runDialog = async (task) => {
+    onDialog(true);
+    try {
+      return await task();
+    } finally {
+      onDialog(false);
+    }
+  };
+  const ui = {
+    ...ctx.ui,
+    select: (...args) => runDialog(() => ctx.ui.select(...args)),
+    confirm: (...args) => runDialog(() => ctx.ui.confirm(...args))
+  };
+  return new Proxy(ctx, {
+    get(target, key, receiver) {
+      return key === "ui" ? ui : Reflect.get(target, key, receiver);
+    }
+  });
+}
+
+// src/commands/command-execution.ts
+async function executeRecoveryCommand(rawArgs, ctx, signal, loaders, onCommit, setup) {
+  try {
+    const [subcommand, ...rest] = splitArgs(rawArgs);
+    if (subcommand !== "sync" && subcommand !== "pull" && subcommand !== "push") {
+      throw new Error(`Unsupported sync recovery route: ${subcommand ?? "missing"}`);
+    }
+    const options = parseOptions(rest);
+    if (setup !== void 0) options.setup = setup;
+    if (signal) options.signal = signal;
+    if (onCommit) options.onCommit = onCommit;
+    options.reload = false;
+    options.auto = false;
+    validateCommandOptions(subcommand, options);
+    const operations = await loaders.operations();
+    throwIfAborted(options.signal);
+    if (subcommand === "push") {
+      const outcome = await withLock("push", () => operations.push(ctx, options));
+      return { kind: "completed", ...outcome ? { outcome } : {} };
+    }
+    if (subcommand === "pull") {
+      const outcome = await withLock("pull", () => operations.pull(ctx, options));
+      return { kind: "completed", ...outcome ? { outcome } : {} };
+    }
+    await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
+    return { kind: "completed" };
+  } catch (error) {
+    if (signal?.aborted) return { kind: "failed" };
+    setSyncStatus(ctx, void 0);
+    if (error instanceof RemoteSelectionMismatchError) {
+      return { kind: "remote-selection-required", decision: error.decision };
+    }
+    if (isSyncDecisionRequiredError(error)) {
+      return { kind: "decision-required", decision: error.decision };
+    }
+    ctx.ui.notify(syncErrorGuidance(error), "error");
+    return { kind: "failed" };
+  }
+}
+async function executeCommand(rawArgs, ctx, signal, loaders, onCommit, setup, onDialog, retryRefusal = false) {
+  ctx = trackOperationDialogs(ctx, onDialog);
+  try {
+    const command = await resolveSyncCommand(rawArgs, ctx);
+    if (signal?.aborted || !command) return { kind: "completed" };
+    const { subcommand, rest } = command;
+    const options = parseOptions(rest);
+    if (setup !== void 0) options.setup = setup;
+    if (signal) options.signal = signal;
+    if (onCommit) options.onCommit = onCommit;
+    validateCommandOptions(subcommand, options);
+    if (retryRefusal) {
+      if (subcommand !== "sync") throw new Error("A refused-model retry is available only for merged sync.");
+      options.agentRetryRefusal = true;
+    }
+    switch (subcommand) {
+      case "help":
+        ctx.ui.notify(usage(), "info");
+        return { kind: "completed" };
+      case "use": {
+        const { useSyncSetup } = await loaders.setupSwitch();
+        throwIfAborted(options.signal);
+        await useSyncSetup(
+          ctx,
+          options.args[0] ?? "",
+          async (selectedSetup) => {
+            const operations = await loaders.operations();
+            throwIfAborted(options.signal);
+            return withLock("pull", () => operations.pull(ctx, { ...options, setup: selectedSetup }));
+          },
+          void 0,
+          options.signal
+        );
+        return { kind: "completed" };
+      }
+      case "init":
+        await initConfig(ctx, signal);
+        return { kind: "completed" };
+      case "config":
+        await showConfig(ctx, options);
+        return { kind: "completed" };
+      case "files": {
+        const { showFileSelection } = await import("./file-selection-FBLKM25V.ts");
+        throwIfAborted(options.signal);
+        await showFileSelection(ctx, options.setup, options.signal);
+        return { kind: "completed" };
+      }
+      case "status": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.status(ctx, options);
+        return { kind: "completed" };
+      }
+      case "diff": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.diff(ctx, options);
+        return { kind: "completed" };
+      }
+      case "conflicts": {
+        const { showConflicts } = await import("./conflict-review-BQSHSJB3.ts");
+        throwIfAborted(options.signal);
+        await withLock("sync", () => showConflicts(ctx, options));
+        return { kind: "completed" };
+      }
+      case "doctor": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.doctor(ctx, options);
+        return { kind: "completed" };
+      }
+      case "push": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        const outcome = await withLock("push", () => operations.push(ctx, options));
+        return { kind: "completed", ...outcome ? { outcome } : {} };
+      }
+      case "pull": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        const outcome = await withLock("pull", () => operations.pull(ctx, options));
+        return { kind: "completed", ...outcome ? { outcome } : {} };
+      }
+      case "sync": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        const outcome = await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
+        return { kind: "completed", ...retryRefusal && outcome ? { outcome } : {} };
+      }
+      case "history": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.history(ctx, options);
+        return { kind: "completed" };
+      }
+      case "rollback": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await withLock("rollback", () => operations.rollback(ctx, options));
+        return { kind: "completed" };
+      }
+      case "migrate-state":
+        await migrateStateDirectory(ctx, options);
+        return { kind: "completed" };
+      case "unlock":
+        await unlock(ctx, options);
+        return { kind: "completed" };
+      default:
+        ctx.ui.notify(`Unknown /sync command: ${subcommand}
+
+${usage()}`, "warning");
+        return { kind: "failed" };
+    }
+  } catch (error) {
+    if (signal?.aborted) return { kind: "failed" };
+    setSyncStatus(ctx, void 0);
+    if (error instanceof SetupPullRequiresUiError) throw error;
+    if (error instanceof RemoteSelectionMismatchError) {
+      return { kind: "remote-selection-required", decision: error.decision };
+    }
+    if (isSyncDecisionRequiredError(error)) {
+      return { kind: "decision-required", decision: error.decision };
+    }
+    ctx.ui.notify(syncErrorGuidance(error), "error");
+    return { kind: "failed" };
+  }
+}
+async function migrateStateDirectory(ctx, options) {
+  const notice = stateDirectoryMigrationNotice();
+  if (!notice) {
+    ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+    return;
+  }
+  if (!options.yes && !await ctx.ui.confirm(
+    "Migrate pi-sync state directory",
+    "Confirm that every other Pi process is closed. pi-sync will atomically rename .pisync/ to pi-sync/ without merging or deleting either root.",
+    { signal: options.signal }
+  )) {
+    ctx.ui.notify("pi-sync state migration cancelled.", "info");
+    return;
+  }
+  throwIfAborted(options.signal);
+  const result = await migrateLegacyStateDirectory();
+  throwIfAborted(options.signal);
+  if (result.status === "ready") {
+    ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+    return;
+  }
+  ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
+}
+async function initConfig(ctx, signal) {
+  const configPath = localConfigPath();
+  if (await readLocalConfigObject()) {
+    ctx.ui.notify(`Config already exists: ${await activeLocalConfigPath()}`, "info");
+    return;
+  }
+  if (ctx.mode === "tui") {
+    const { showSetupWizard } = await import("./setup-wizard-OHZXJVQZ.ts");
+    throwIfAborted(signal);
+    await showSetupWizard(ctx, signal);
+    return;
+  }
+  await createLocalConfigDocument(localConfigTemplate());
+  ctx.ui.notify(`Created ${configPath}. Add a storage connection and sync setup before syncing.`, "info");
+}
+async function showConfig(ctx, options) {
+  const config = await loadConfig(options.setup);
+  const warnings = [
+    ...config.backend.type === "s3" ? sessionTokenWarnings(config.backend.profile) : [],
+    ...syncSessionsWarnings(config)
+  ];
+  const storageLines = configStorageLines(config);
+  ctx.ui.notify(
+    [
+      "pi-sync config:",
+      `sync setup: ${config.setupName}`,
+      `storage connection: ${config.connectionName}`,
+      ...storageLines,
+      `storage path: ${config.storagePath}`,
+      `automatic sync: ${automaticSyncSummary(config.automatic)}`,
+      `settings field merge: ${config.mergeSettings ? "On (experimental)" : "Off"}`,
+      `machine-local settings.json fields: ${(config.localFields ?? []).map(safeTerminalText).join(", ") || "none"}`,
+      `startup transfer: ${startupTransferSummary(config)}`,
+      `agent mode: ${config.agentMode ? "On (experimental)" : "Off"}`,
+      `continuous sync: ${config.continuous ? config.agentMode ? "On (experimental)" : "paused; Agent mode is Off" : "Off"}`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
+      `settings file: ${localConfigPath()}`,
+      ...warnings
+    ].join("\n"),
+    warnings.length > 0 ? "warning" : "info"
+  );
+}
+function configStorageLines(config) {
+  switch (config.backend.type) {
+    case "git":
+      return [
+        "kind: git",
+        `remote: ${displayGitRemote(config.backend.profile.remote)}`,
+        "authentication: existing Git/SSH credentials (not stored)",
+        `branch: ${config.backend.destination.branch}`
+      ];
+    case "webdav":
+      return [
+        "kind: webdav",
+        `url: ${displayWebDavUrl(config.backend.profile.url, config.backend.profile.username)}`,
+        "username: configured (value hidden)",
+        "password: configured"
+      ];
+    case "s3":
+      return [
+        "kind: s3",
+        `endpoint: ${config.backend.profile.endpoint}`,
+        `bucket: ${config.backend.destination.bucket}`,
+        `region: ${config.backend.profile.region}`,
+        "access key id: configured",
+        "secret access key: configured",
+        `session token: ${config.backend.profile.sessionToken ? "configured" : "not configured"}`
+      ];
+  }
+}
+function displayGitRemote(value) {
+  if (!value) return "missing";
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return value.replace(/^(?:[^@\s]+@)?(?<host>[^:]+):.+$/u, "$<host>:\u2026");
+  }
+}
+function displayWebDavUrl(value, username) {
+  if (!value) return "missing";
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return username ? `${url.origin}/\u2026` : `${url.origin}${url.pathname}`;
+  } catch {
+    return "invalid (value hidden)";
+  }
+}
+
+// src/commands/command-handler.ts
+async function handleCommand(rawArgs, ctx, sessionSignal, loaders, attention, onExplicitSync) {
+  await reconcileObservation(attention, sessionSignal);
+  if (sessionSignal.aborted) return;
+  const run = (route, signal, onCommit, target, onDialog, retryRefusal = false) => {
+    const [command, ...args] = splitArgs(route);
+    if (command === "sync" && !retryRefusal) {
+      try {
+        const options = parseOptions(args);
+        validateCommandOptions("sync", options);
+        onExplicitSync?.(target ?? options.setup);
+      } catch {
+      }
+    }
+    return executeCommand(
+      route,
+      ctx,
+      combineSignals(sessionSignal, signal),
+      loaders,
+      observationCommitCallback(attention, sessionSignal, onCommit),
+      target,
+      onDialog,
+      retryRefusal
+    );
+  };
+  if (!rawArgs.trim()) {
+    try {
+      const { showSyncManager } = await import("./manager-ui-DGRTG76I.ts");
+      if (sessionSignal.aborted) return;
+      await showSyncManager(ctx, run, sessionSignal, {
+        getAttention: () => attention.current(),
+        getObservation: () => attention.observation(),
+        onObservationInvalidated: () => attention.clearObservation(),
+        onSelectionResolved: (expected) => {
+          if (attention.current() === expected) attention.clear(ctx);
+        }
+      });
+    } catch (error) {
+      if (sessionSignal.aborted) return;
+      setSyncStatus(ctx, void 0);
+      ctx.ui.notify(errorMessage(error), "error");
+    }
+    await reconcileObservation(attention, sessionSignal);
+    if (!sessionSignal.aborted) await attention.publish(ctx, sessionSignal);
+    return;
+  }
+  const result = await run(rawArgs);
+  if (result.kind === "decision-required") {
+    ctx.ui.notify(result.decision.directMessage, "error");
+  } else if (result.kind === "remote-selection-required") {
+    const origin = directSelectionOrigin(rawArgs);
+    if (origin) attention.set(result.decision, origin);
+    const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
+    if (origin && ctx.mode === "tui" && !deterministic) {
+      await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
+    } else {
+      ctx.ui.notify(
+        formatRemoteSelectionMismatch(
+          result.decision.setupName,
+          result.decision.localInclude,
+          result.decision.remoteInclude
+        ),
+        "error"
+      );
+    }
+  }
+  await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
+  await reconcileSelectionAttention(ctx, attention, sessionSignal);
+  await reconcileObservation(attention, sessionSignal);
+  if (!sessionSignal.aborted) await attention.publish(ctx, sessionSignal);
+}
+function observationCommitCallback(attention, sessionSignal, onCommit) {
+  const observed = attention.observation();
+  return () => {
+    if (!sessionSignal.aborted && attention.observation() === observed) attention.clearObservation();
+    onCommit?.();
+  };
+}
+async function reconcileObservation(attention, signal) {
+  const observed = attention.observation();
+  if (!observed || signal.aborted) return;
+  try {
+    const config = await loadConfig();
+    if (signal.aborted || attention.observation() !== observed) return;
+    if (!observationMatchesConfig(observed, config)) {
+      attention.clearObservation();
+      return;
+    }
+    const state = await readStateForConfig(config);
+    if (signal.aborted || attention.observation() !== observed) return;
+    if (syncStateFingerprint(state) !== observed.inspection.stateIdentity) attention.clearObservation();
+  } catch {
+    if (!signal.aborted && attention.observation() === observed) attention.clearObservation();
+  }
+}
+async function clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, signal) {
+  if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
+  const [command, ...rest] = splitArgs(rawArgs);
+  if (command !== "sync" && command !== "pull" && command !== "push") return;
+  const current = attention.current();
+  if (!current) return;
+  try {
+    const options = parseOptions(rest);
+    const setupName = options.setup ?? (await loadConfig()).setupName;
+    if (signal.aborted || attention.current() !== current) return;
+    if (current.decision.setupName === setupName) attention.clear(ctx);
+  } catch {
+  }
+}
+async function reconcileSelectionAttention(ctx, attention, signal) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  try {
+    const config = await loadConfig(current.decision.setupName);
+    if (signal.aborted || attention.current() !== current) return;
+    if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
+  } catch {
+    if (!signal.aborted && attention.current() === current) attention.clear(ctx);
+  }
+}
+function directSelectionOrigin(rawArgs) {
+  const command = splitArgs(rawArgs)[0];
+  return command === "sync" || command === "pull" || command === "push" ? command : void 0;
+}
+async function resolveSelectionAttention(ctx, attention, signal, loaders, options = {}) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  const { dispatchManagerResult } = await import("./manager-result-dispatcher-NODX3KKH.ts");
+  if (signal.aborted || attention.current() !== current) return;
+  await dispatchManagerResult(
+    ctx,
+    { kind: "remote-selection-required", decision: current.decision },
+    current.origin,
+    (route, actionSignal, onCommit, target) => {
+      const execute = () => executeRecoveryCommand(
+        route,
+        ctx,
+        combineSignals(signal, actionSignal),
+        loaders,
+        observationCommitCallback(attention, signal, onCommit),
+        target
+      );
+      return options.withStateAccess ? options.withStateAccess(execute) : execute();
+    },
+    signal,
+    {
+      cancelLabel: options.cancelLabel,
+      withStateAccess: options.withStateAccess,
+      onSelectionResolved: () => {
+        if (attention.current() === current) attention.clear(ctx);
+      }
+    }
+  );
+}
+export {
+  handleCommand,
+  resolveSelectionAttention
+};
+//# sourceMappingURL=command-handler-FO6F2APH.ts.map