opensyn 0.1.0

package/index.ts

@@ -0,0 +1,3507 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+type ToolContent = { type: "text"; text: string };
+
+type SemanticHint = {
+  activity_kind?: string;
+  operator_focus?: string;
+  status_label?: string;
+  matched_item_kind?: string;
+  summary_label?: string;
+  primary_signature?: string;
+  primary_artifact?: string;
+};
+
+type ContextLike = {
+  title?: string;
+  summary?: string;
+  project_root?: string;
+  goal_guess?: string;
+  pack_type?: string;
+  recent_failures?: string[];
+  recent_changes?: string[];
+  commands?: string[];
+  files_touched?: string[];
+  semantic_hint?: SemanticHint;
+};
+
+type SearchLike = {
+  title?: string;
+  snippet?: string;
+  item_kind?: string;
+  semantic_hint?: SemanticHint;
+};
+
+type AssetLike = {
+  title?: string;
+  summary?: string;
+  kind?: string;
+  status?: string;
+  revision?: number;
+  semantic_hint?: SemanticHint & {
+    asset_kind?: string;
+    revision?: number;
+  };
+};
+
+type AssetHistoryLike = {
+  asset_id?: string;
+  lineage_key?: string;
+  revision?: number;
+  change_reason?: string;
+  asset?: AssetLike;
+  semantic_hint?: SemanticHint & {
+    asset_kind?: string;
+    revision?: number;
+  };
+};
+
+type AssetDiffLike = {
+  asset_id?: string;
+  lineage_key?: string;
+  from_revision?: number;
+  to_revision?: number;
+  title_changed?: boolean;
+  summary_changed?: boolean;
+  content_changed?: boolean;
+  added_tags?: string[];
+  removed_tags?: string[];
+  semantic_hint?: SemanticHint & {
+    asset_kind?: string;
+  };
+};
+
+type CollectionSettingsLike = {
+  project_root?: string;
+  mode?: string;
+  auto_distill?: boolean;
+  distill_on_flush?: boolean;
+  semantic_hint?: SemanticHint;
+};
+
+type ReviewPolicySettingsLike = {
+  project_root?: string;
+  auto_approve_memory?: boolean;
+  auto_approve_skill?: boolean;
+  auto_approve_rule?: boolean;
+  auto_approve_negative_example?: boolean;
+  min_confidence?: number;
+  max_auto_approve_revision?: number;
+  require_reapproval_on_revision_bump?: boolean;
+  semantic_hint?: SemanticHint;
+};
+
+type DistillationSettingsLike = {
+  project_root?: string;
+  backend?: string;
+  allow_network?: boolean;
+  restricted_to_host_model?: boolean;
+  auto_enqueue_on_flush?: boolean;
+  auto_apply_submissions?: boolean;
+  semantic_hint?: SemanticHint;
+};
+
+type DistillationJobLike = {
+  id?: string;
+  project_root?: string;
+  context_pack_id?: string;
+  status?: string;
+  title?: string;
+  source_summary?: string;
+  prompt?: string;
+  submitted_asset_ids?: string[];
+  semantic_hint?: SemanticHint;
+};
+
+type DistillationWorkPacketLike = {
+  job?: DistillationJobLike;
+  output_spec?: {
+    allowed_asset_kinds?: string[];
+    required_fields?: string[];
+    completion_tool?: string;
+    requeue_tool?: string;
+    completion_argument_key?: string;
+    notes?: string[];
+  };
+  executor_prompt?: string;
+  completion_arguments_template?: unknown;
+  runtime_overlay?: RuntimeOverlayLike | null;
+  review_policy?: ReviewPolicySettingsLike | null;
+  semantic_hint?: SemanticHint;
+};
+
+type AutonomousTickLike = {
+  contract_version?: string;
+  project_root?: string;
+  action?: string;
+  automation_state?: string;
+  cycle_plan?: {
+    primary_steps?: Array<unknown>;
+    fallback_steps?: Array<unknown>;
+    resume_steps?: Array<unknown>;
+  };
+  execution_plan?: Array<{
+    kind?: string;
+    title?: string;
+    tool?: string | null;
+    arguments_template?: unknown;
+    delay_secs?: number;
+    notes?: string[];
+  }>;
+  transition?: {
+    kind?: string;
+    success_state?: string;
+    failure_state?: string;
+    success_action_tool?: string | null;
+    success_action_arguments_template?: unknown;
+    failure_action_tool?: string | null;
+    failure_action_arguments_template?: unknown;
+    resume_action_tool?: string | null;
+    resume_action_arguments_template?: unknown;
+    resume_after_secs?: number;
+    stop_after_transition?: boolean;
+  };
+  pending_distillation_jobs?: number;
+  claimed_job_id?: string | null;
+  work_packet?: DistillationWorkPacketLike | null;
+  runtime_overlay?: RuntimeOverlayLike;
+  next_action_tool?: string | null;
+  next_action_instruction?: string;
+  should_continue?: boolean;
+  poll_after_secs?: number;
+  next_action_arguments_template?: unknown;
+  semantic_hint?: SemanticHint;
+};
+
+type ProjectionSettingsLike = {
+  project_root?: string;
+  enabled?: boolean;
+  host?: string;
+  target_root?: string;
+  auto_apply_approved?: boolean;
+  semantic_hint?: SemanticHint;
+};
+
+type ProjectionLike = {
+  asset_id?: string;
+  status?: string;
+  content?: string;
+  semantic_hint?: SemanticHint;
+};
+
+type ProjectionSyncLike = {
+  project_root?: string;
+  host?: string;
+  target_root?: string;
+  applied_asset_count?: number;
+  applied_record_count?: number;
+  skipped_asset_ids?: string[];
+  records?: ProjectionLike[];
+  semantic_hint?: SemanticHint;
+};
+
+type RuntimeOverlaySkillLike = {
+  asset_id?: string;
+  lineage_key?: string;
+  revision?: number;
+  title?: string;
+  summary?: string;
+  relative_path?: string;
+};
+
+type RuntimeOverlayLike = {
+  project_root?: string;
+  host?: string;
+  approved_asset_count?: number;
+  approved_asset_ids?: string[];
+  pending_distillation_jobs?: number | null;
+  target_root?: string | null;
+  index_markdown?: string;
+  memory_markdown?: string;
+  agents_markdown?: string;
+  automation_markdown?: string;
+  soul_markdown?: string;
+  skills?: RuntimeOverlaySkillLike[];
+  managed_files?: string[];
+  semantic_hint?: SemanticHint;
+};
+
+type BackgroundWatchStatus = {
+  supported: boolean;
+  running: boolean;
+  pid?: number;
+  source: "watch_linux" | "unsupported_platform";
+  project_root: string;
+  platform: string;
+  state_path: string;
+  log_path: string;
+  reason?: string;
+};
+
+type DistillationWorkerStatus = {
+  supported: boolean;
+  enabled: boolean;
+  running: boolean;
+  pid?: number;
+  source: "openclaw_host_model_agent";
+  project_root: string;
+  state_path: string;
+  log_path: string;
+  openclaw_bin: string;
+  agent_id: string;
+  interval_secs: number;
+  last_exit_code?: number | null;
+  last_error?: string;
+  last_finished_at?: string;
+  reason?: string;
+};
+
+type DistillationWorkerHealth = {
+  status: "running" | "disabled" | "stopped" | "auth_required" | "error";
+  summary: string;
+  action?: string;
+  log_path: string;
+  last_finished_at?: string;
+};
+
+type ShellHookDoctorLike = {
+  installed?: boolean;
+  self_test?: { success?: boolean };
+  recommendations?: Array<{ issue?: string; command?: string; severity?: string }>;
+  notes?: string[];
+  rc_file?: string;
+};
+
+type ShellCaptureHealth = {
+  status: "ready" | "pending_reload" | "missing" | "error";
+  summary: string;
+  action?: string;
+};
+
+type UserNextStep = {
+  status: "none" | "optional" | "required";
+  code:
+    | "none"
+    | "reload_shell"
+    | "repair_command_capture"
+    | "configure_model_auth"
+    | "restart_background_watch"
+    | "repair_distillation_worker"
+    | "unsupported_platform";
+  summary: string;
+  action?: string;
+};
+
+type OpenSynConfig = {
+  runtimeRoot?: string;
+  dbPath?: string;
+  cliBin?: string;
+  daemonBin?: string;
+  helperPath?: string;
+  runnerPath?: string;
+  defaultShell?: string;
+  defaultProjectRoot?: string;
+  defaultWindowSecs?: number;
+  defaultSearchLimit?: number;
+  daemonTimeoutMs?: number;
+  projectionBundleRoot?: string;
+  projectionHost?: string;
+  projectionAutoApplyApproved?: boolean;
+  watchIdleWindowSecs?: number;
+  watchPollIntervalSecs?: number;
+  openclawBin?: string;
+  distillationWorkerEnabled?: boolean;
+  distillationWorkerIntervalSecs?: number;
+  distillationWorkerAgentId?: string;
+};
+
+type ResolvedOpenSynConfig = {
+  runtimeRoot: string;
+  dbPath: string;
+  cliBin: string;
+  daemonBin: string;
+  helperPath: string;
+  runnerPath: string;
+  defaultShell: string;
+  defaultProjectRoot?: string;
+  defaultWindowSecs: number;
+  defaultSearchLimit: number;
+  daemonTimeoutMs: number;
+  projectionBundleRoot: string;
+  projectionHost: string;
+  projectionAutoApplyApproved: boolean;
+  watchIdleWindowSecs: number;
+  watchPollIntervalSecs: number;
+  openclawBin: string;
+  distillationWorkerEnabled: boolean;
+  distillationWorkerIntervalSecs: number;
+  distillationWorkerAgentId: string;
+};
+
+type RpcResponse = {
+  result?: unknown;
+  error?: {
+    message?: string;
+  };
+};
+
+type SpawnResponse = {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+};
+
+const PLUGIN_ID = "opensyn";
+const PACKAGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
+
+function packageRuntimePath(...segments: string[]): string {
+  return path.join(PACKAGE_ROOT, "runtime", ...segments);
+}
+
+function repoFallbackPath(...segments: string[]): string {
+  return path.resolve(PACKAGE_ROOT, "..", "..", ...segments);
+}
+
+function resolvePreferredPath(candidates: Array<string | undefined>): string | undefined {
+  for (const candidate of candidates) {
+    if (!candidate) {
+      continue;
+    }
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates.find(Boolean);
+}
+
+function readJsonFile<T>(filePath: string): T | undefined {
+  if (!existsSync(filePath)) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8")) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+function ensureProjectRoot(projectRoot: string): void {
+  mkdirSync(projectRoot, { recursive: true });
+}
+
+function defaultDbPath(): string {
+  const home = process.env.HOME || os.homedir();
+  return path.join(home, ".opensyn", "opensyn.db");
+}
+
+function defaultRuntimeRoot(): string {
+  const home = process.env.HOME || os.homedir();
+  return path.join(home, ".opensyn");
+}
+
+function defaultShell(): string {
+  return path.basename(process.env.SHELL || "bash") || "bash";
+}
+
+function defaultOpenClawBin(): string {
+  if (process.env.OPENCLAW_BIN) {
+    return process.env.OPENCLAW_BIN;
+  }
+  const pathEnv = process.env.PATH || "";
+  for (const entry of pathEnv.split(path.delimiter)) {
+    if (!entry) {
+      continue;
+    }
+    const candidate = path.join(entry, "openclaw");
+    if (existsSync(candidate)) {
+      try {
+        return realpathSync(candidate);
+      } catch {
+        return candidate;
+      }
+    }
+  }
+  return "openclaw";
+}
+
+function stableNodeRunner(): string {
+  if (process.execPath && existsSync(process.execPath)) {
+    return process.execPath;
+  }
+  return existsSync("/usr/bin/node") ? "/usr/bin/node" : process.execPath;
+}
+
+function defaultProjectionBundleRoot(): string {
+  const home = process.env.HOME || os.homedir();
+  return path.join(home, ".openclaw", "workspace");
+}
+
+function syncRuntimeTree(sourceDir: string, destDir: string): void {
+  if (!existsSync(sourceDir)) {
+    return;
+  }
+
+  mkdirSync(destDir, { recursive: true });
+  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      syncRuntimeTree(sourcePath, destPath);
+      continue;
+    }
+    const sourceStat = statSync(sourcePath);
+    const needsCopy =
+      !existsSync(destPath) ||
+      statSync(destPath).size !== sourceStat.size ||
+      statSync(destPath).mtimeMs < sourceStat.mtimeMs;
+    if (!needsCopy) {
+      continue;
+    }
+    mkdirSync(path.dirname(destPath), { recursive: true });
+    copyFileSync(sourcePath, destPath);
+    chmodSync(destPath, sourceStat.mode);
+  }
+}
+
+function ensureRuntimeRootAssets(runtimeRoot: string): string {
+  const managedRuntimeDir = path.join(runtimeRoot, "runtime");
+  syncRuntimeTree(packageRuntimePath(), managedRuntimeDir);
+  return managedRuntimeDir;
+}
+
+function resolveOpenSynConfig(
+  config: OpenSynConfig,
+  defaults?: { defaultProjectRoot?: string },
+): ResolvedOpenSynConfig {
+  const runtimeRoot = config.runtimeRoot || defaultRuntimeRoot();
+  const managedRuntimeDir = ensureRuntimeRootAssets(runtimeRoot);
+  const daemonBin = resolvePreferredPath([
+    config.daemonBin,
+    process.env.OPENSYN_DAEMON_BIN,
+    path.join(managedRuntimeDir, "opensyn-daemon"),
+    packageRuntimePath("opensyn-daemon"),
+    repoFallbackPath("target", "debug", "synapse-daemon"),
+    repoFallbackPath("target", "release", "synapse-daemon"),
+  ]) || path.join(managedRuntimeDir, "opensyn-daemon");
+
+  const cliBin = resolvePreferredPath([
+    config.cliBin,
+    process.env.OPENSYN_CLI_BIN,
+    path.join(managedRuntimeDir, "opensyn-cli"),
+    packageRuntimePath("opensyn-cli"),
+    repoFallbackPath("target", "debug", "synapse-cli"),
+    repoFallbackPath("target", "release", "synapse-cli"),
+  ]) || path.join(managedRuntimeDir, "opensyn-cli");
+
+  const helperPath =
+    resolvePreferredPath([
+      config.helperPath,
+      path.join(managedRuntimeDir, "opensyn-ingest-command"),
+      packageRuntimePath("opensyn-ingest-command"),
+      repoFallbackPath("scripts", "synapse-ingest-command"),
+    ]) || path.join(managedRuntimeDir, "opensyn-ingest-command");
+
+  const runnerPath =
+    resolvePreferredPath([
+      config.runnerPath,
+      path.join(managedRuntimeDir, "opensyn-run"),
+      packageRuntimePath("opensyn-run"),
+      repoFallbackPath("scripts", "synapse-run"),
+    ]) || path.join(managedRuntimeDir, "opensyn-run");
+
+  return {
+    runtimeRoot,
+    dbPath: config.dbPath || path.join(runtimeRoot, "opensyn.db"),
+    cliBin,
+    daemonBin,
+    helperPath,
+    runnerPath,
+    defaultShell: config.defaultShell || defaultShell(),
+    defaultProjectRoot: config.defaultProjectRoot || defaults?.defaultProjectRoot,
+    defaultWindowSecs: config.defaultWindowSecs ?? 300,
+    defaultSearchLimit: config.defaultSearchLimit ?? 10,
+    daemonTimeoutMs: config.daemonTimeoutMs ?? 10_000,
+    projectionBundleRoot: config.projectionBundleRoot || defaultProjectionBundleRoot(),
+    projectionHost: config.projectionHost || "openclaw",
+    projectionAutoApplyApproved: config.projectionAutoApplyApproved ?? true,
+    watchIdleWindowSecs: config.watchIdleWindowSecs ?? 10,
+    watchPollIntervalSecs: config.watchPollIntervalSecs ?? 2,
+    openclawBin: config.openclawBin || defaultOpenClawBin(),
+    distillationWorkerEnabled: config.distillationWorkerEnabled ?? true,
+    distillationWorkerIntervalSecs: config.distillationWorkerIntervalSecs ?? 60,
+    distillationWorkerAgentId: config.distillationWorkerAgentId || "main",
+  };
+}
+
+function backgroundWatchDir(config: ResolvedOpenSynConfig, projectRoot: string): string {
+  const projectHash = createHash("sha256").update(projectRoot).digest("hex").slice(0, 16);
+  return path.join(config.runtimeRoot, "background", projectHash);
+}
+
+function backgroundWatchStatePath(config: ResolvedOpenSynConfig, projectRoot: string): string {
+  return path.join(backgroundWatchDir(config, projectRoot), "watch-linux.json");
+}
+
+function backgroundWatchLogPath(config: ResolvedOpenSynConfig, projectRoot: string): string {
+  return path.join(backgroundWatchDir(config, projectRoot), "watch-linux.log");
+}
+
+function distillationWorkerStatePath(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): string {
+  return path.join(backgroundWatchDir(config, projectRoot), "host-distiller.json");
+}
+
+function distillationWorkerLogPath(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): string {
+  return path.join(backgroundWatchDir(config, projectRoot), "host-distiller.log");
+}
+
+function isPidAlive(pid?: number): boolean {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getBackgroundWatchStatus(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): BackgroundWatchStatus {
+  const statePath = backgroundWatchStatePath(config, projectRoot);
+  const logPath = backgroundWatchLogPath(config, projectRoot);
+  if (process.platform !== "linux") {
+    return {
+      supported: false,
+      running: false,
+      source: "unsupported_platform",
+      project_root: projectRoot,
+      platform: process.platform,
+      state_path: statePath,
+      log_path: logPath,
+      reason: "background_watch_linux_only",
+    };
+  }
+
+  const state = readJsonFile<{ pid?: number }>(statePath);
+  const pid = state?.pid;
+  return {
+    supported: true,
+    running: isPidAlive(pid),
+    pid,
+    source: "watch_linux",
+    project_root: projectRoot,
+    platform: process.platform,
+    state_path: statePath,
+    log_path: logPath,
+  };
+}
+
+async function ensureBackgroundWatch(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): Promise<BackgroundWatchStatus> {
+  const status = getBackgroundWatchStatus(config, projectRoot);
+  if (!status.supported || status.running) {
+    return status;
+  }
+
+  const statePath = backgroundWatchStatePath(config, projectRoot);
+  const logPath = backgroundWatchLogPath(config, projectRoot);
+  mkdirSync(path.dirname(statePath), { recursive: true });
+  const logFd = openSync(logPath, "a");
+  const child = spawn(
+    config.daemonBin,
+    [
+      "watch-linux",
+      "--db",
+      config.dbPath,
+      "--project-root",
+      projectRoot,
+      "--idle-window-secs",
+      String(config.watchIdleWindowSecs),
+      "--poll-interval-secs",
+      String(config.watchPollIntervalSecs),
+    ],
+    {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+    },
+  );
+  child.unref();
+  closeSync(logFd);
+
+  writeFileSync(
+    statePath,
+    `${JSON.stringify(
+      {
+        pid: child.pid,
+        source: "watch_linux",
+        project_root: projectRoot,
+        started_at: new Date().toISOString(),
+        log_path: logPath,
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+  return getBackgroundWatchStatus(config, projectRoot);
+}
+
+function stopBackgroundWatch(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): BackgroundWatchStatus {
+  const status = getBackgroundWatchStatus(config, projectRoot);
+  if (status.running && status.pid) {
+    try {
+      process.kill(status.pid, "SIGTERM");
+    } catch {
+      // Ignore pid races; the state file is still cleaned up below.
+    }
+  }
+  rmSync(status.state_path, { force: true });
+  return getBackgroundWatchStatus(config, projectRoot);
+}
+
+function getDistillationWorkerStatus(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): DistillationWorkerStatus {
+  const statePath = distillationWorkerStatePath(config, projectRoot);
+  const logPath = distillationWorkerLogPath(config, projectRoot);
+  const state = readJsonFile<{
+    pid?: number;
+    last_exit_code?: number | null;
+    last_error?: string;
+    last_finished_at?: string;
+  }>(statePath);
+  const pid = state?.pid;
+  return {
+    supported: true,
+    enabled: config.distillationWorkerEnabled,
+    running: config.distillationWorkerEnabled && isPidAlive(pid),
+    pid,
+    source: "openclaw_host_model_agent",
+    project_root: projectRoot,
+    state_path: statePath,
+    log_path: logPath,
+    openclaw_bin: config.openclawBin,
+    agent_id: config.distillationWorkerAgentId,
+    interval_secs: config.distillationWorkerIntervalSecs,
+    last_exit_code: state?.last_exit_code,
+    last_error: state?.last_error,
+    last_finished_at: state?.last_finished_at,
+    reason: config.distillationWorkerEnabled ? undefined : "disabled_by_config",
+  };
+}
+
+function summarizeDistillationWorkerError(error: string): string {
+  const trimmed = error.trim();
+  if (!trimmed) {
+    return "OpenSyn has not recorded a recent distillation worker error.";
+  }
+  const firstLine = trimmed.split("\n").find(Boolean) || trimmed;
+  if (firstLine.length <= 220) {
+    return firstLine;
+  }
+  return `${firstLine.slice(0, 217)}...`;
+}
+
+function buildDistillationWorkerHealth(
+  status: DistillationWorkerStatus,
+): DistillationWorkerHealth {
+  if (!status.enabled) {
+    return {
+      status: "disabled",
+      summary: "The plugin-managed host-model distillation worker is disabled by config.",
+      log_path: status.log_path,
+      last_finished_at: status.last_finished_at,
+    };
+  }
+
+  const lastError = status.last_error?.trim() || "";
+  if (lastError) {
+    if (lastError.includes("No API key found for provider")) {
+      return {
+        status: "auth_required",
+        summary:
+          "OpenClaw host-model distillation is blocked because the selected OpenClaw agent does not have model auth configured.",
+        action:
+          `Configure auth for agent '${status.agent_id}' in OpenClaw, then run openclaw repair_opensyn or wait for the next worker interval.`,
+        log_path: status.log_path,
+        last_finished_at: status.last_finished_at,
+      };
+    }
+    return {
+      status: "error",
+      summary: summarizeDistillationWorkerError(lastError),
+      action: `Inspect ${status.log_path} for the full worker log, then run openclaw repair_opensyn if needed.`,
+      log_path: status.log_path,
+      last_finished_at: status.last_finished_at,
+    };
+  }
+
+  if (status.running) {
+    return {
+      status: "running",
+      summary: "The plugin-managed host-model distillation worker is running.",
+      log_path: status.log_path,
+      last_finished_at: status.last_finished_at,
+    };
+  }
+
+  return {
+    status: "stopped",
+    summary: "The plugin-managed host-model distillation worker is not currently running.",
+    action: "Run openclaw repair_opensyn to restart the worker.",
+    log_path: status.log_path,
+    last_finished_at: status.last_finished_at,
+  };
+}
+
+function buildShellCaptureHealth(doctor: ShellHookDoctorLike | undefined): ShellCaptureHealth {
+  const installed = doctor?.installed ?? false;
+  const recommendations = doctor?.recommendations ?? [];
+  const staleRecommendation = recommendations.find(
+    (entry) => entry.issue === "stale_shell_environment",
+  );
+  const missingRecommendation = recommendations.find(
+    (entry) => entry.issue === "hook_not_installed",
+  );
+
+  if (!installed || missingRecommendation) {
+    return {
+      status: "missing",
+      summary: "Managed command capture is not installed for this shell yet.",
+      action:
+        missingRecommendation?.command ||
+        "Run openclaw enable_opensyn or openclaw repair_opensyn to install the managed shell hook.",
+    };
+  }
+
+  if (staleRecommendation) {
+    return {
+      status: "pending_reload",
+      summary:
+        "Managed command capture is installed and will work for new shells, but the current shell has not reloaded the hook yet.",
+      action:
+        staleRecommendation.command ||
+        (doctor?.rc_file ? `source '${doctor.rc_file}'` : "Open a new shell session."),
+    };
+  }
+
+  return {
+    status: "ready",
+    summary: "Managed command capture is installed and ready.",
+  };
+}
+
+function buildUserNextStep(params: {
+  collectionMode?: string;
+  backgroundWatch?: BackgroundWatchStatus;
+  shellCaptureHealth?: ShellCaptureHealth;
+  distillationWorkerHealth?: DistillationWorkerHealth;
+}): UserNextStep {
+  const collectionMode = params.collectionMode || "unknown";
+  const backgroundWatch = params.backgroundWatch;
+  const shellCaptureHealth = params.shellCaptureHealth;
+  const distillationWorkerHealth = params.distillationWorkerHealth;
+
+  if (collectionMode !== "enabled") {
+    return {
+      status: "none",
+      code: "none",
+      summary: "No manual action required while OpenSyn autonomous collection is disabled.",
+    };
+  }
+
+  if (backgroundWatch && !backgroundWatch.supported) {
+    return {
+      status: "required",
+      code: "unsupported_platform",
+      summary:
+        "Plugin-managed background collection currently requires Linux on the local machine.",
+      action:
+        backgroundWatch.reason ||
+        "Use OpenSyn on a Linux machine, or disable plugin-managed background collection for this project.",
+    };
+  }
+
+  if (distillationWorkerHealth?.status === "auth_required") {
+    return {
+      status: "required",
+      code: "configure_model_auth",
+      summary:
+        "Configure OpenClaw model auth for the managed distillation agent before OpenSyn can keep distilling in the background.",
+      action: distillationWorkerHealth.action,
+    };
+  }
+
+  if (backgroundWatch?.supported && !backgroundWatch.running) {
+    return {
+      status: "required",
+      code: "restart_background_watch",
+      summary:
+        "Background collection is not currently running for this workspace, so new activity is not being captured.",
+      action: "Run openclaw repair_opensyn to restart background collection.",
+    };
+  }
+
+  if (shellCaptureHealth?.status === "missing" || shellCaptureHealth?.status === "error") {
+    return {
+      status: "required",
+      code: "repair_command_capture",
+      summary:
+        "Managed command capture is not active yet, so shell commands from this workstation are not fully captured.",
+      action:
+        shellCaptureHealth.action ||
+        "Run openclaw repair_opensyn to reinstall the managed shell hook.",
+    };
+  }
+
+  if (
+    distillationWorkerHealth &&
+    (distillationWorkerHealth.status === "error" ||
+      distillationWorkerHealth.status === "stopped")
+  ) {
+    return {
+      status: "required",
+      code: "repair_distillation_worker",
+      summary:
+        "The plugin-managed host-model distillation worker is not healthy, so OpenSyn cannot keep refining new activity automatically.",
+      action:
+        distillationWorkerHealth.action ||
+        "Run openclaw repair_opensyn to restart the distillation worker.",
+    };
+  }
+
+  if (shellCaptureHealth?.status === "pending_reload") {
+    return {
+      status: "optional",
+      code: "reload_shell",
+      summary:
+        "OpenSyn is already installed, but the current shell has not reloaded managed command capture yet.",
+      action: shellCaptureHealth.action,
+    };
+  }
+
+  return {
+    status: "none",
+    code: "none",
+    summary: "No manual action required. OpenSyn autonomous collection is ready.",
+  };
+}
+
+async function ensureDistillationWorker(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): Promise<DistillationWorkerStatus> {
+  const status = getDistillationWorkerStatus(config, projectRoot);
+  if (!status.enabled || status.running) {
+    return status;
+  }
+
+  const statePath = distillationWorkerStatePath(config, projectRoot);
+  const logPath = distillationWorkerLogPath(config, projectRoot);
+  mkdirSync(path.dirname(statePath), { recursive: true });
+  const logFd = openSync(logPath, "a");
+  const child = spawn(
+    stableNodeRunner(),
+    [
+      path.join(path.dirname(config.daemonBin), "opensyn-host-distiller.mjs"),
+      "--openclaw-bin",
+      config.openclawBin,
+      "--agent-id",
+      config.distillationWorkerAgentId,
+      "--interval-secs",
+      String(config.distillationWorkerIntervalSecs),
+      "--project-root",
+      projectRoot,
+      "--state-path",
+      statePath,
+    ],
+    {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: process.env,
+    },
+  );
+  child.unref();
+  closeSync(logFd);
+
+  writeFileSync(
+    statePath,
+    `${JSON.stringify(
+      {
+        pid: child.pid,
+        source: "openclaw_host_model_agent",
+        project_root: projectRoot,
+        openclaw_bin: config.openclawBin,
+        agent_id: config.distillationWorkerAgentId,
+        interval_secs: config.distillationWorkerIntervalSecs,
+        started_at: new Date().toISOString(),
+        log_path: logPath,
+        last_exit_code: null,
+        last_error: "",
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+  return getDistillationWorkerStatus(config, projectRoot);
+}
+
+function stopDistillationWorker(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): DistillationWorkerStatus {
+  const status = getDistillationWorkerStatus(config, projectRoot);
+  if (status.running && status.pid) {
+    try {
+      process.kill(status.pid, "SIGTERM");
+    } catch {
+      // Ignore pid races; the state file is still cleaned up below.
+    }
+  }
+  rmSync(status.state_path, { force: true });
+  return getDistillationWorkerStatus(config, projectRoot);
+}
+
+async function runDaemonCommand(
+  config: ResolvedOpenSynConfig,
+  args: string[],
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const timeoutMs = config.daemonTimeoutMs ?? 10_000;
+    const child = spawn(config.daemonBin, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      reject(new Error(`synapse-daemon timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    function finish(fn: () => void) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      fn();
+    }
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      finish(() => {
+        if (code !== 0) {
+          reject(
+            new Error(
+              `synapse-daemon exited with ${code ?? "unknown"}${stderr ? `: ${stderr.trim()}` : ""}`,
+            ),
+          );
+          return;
+        }
+
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+          resolve({
+            stdout,
+            stderr,
+            exitCode: code,
+          } satisfies SpawnResponse);
+          return;
+        }
+
+        try {
+          resolve(JSON.parse(trimmed));
+        } catch {
+          resolve({
+            stdout,
+            stderr,
+            exitCode: code,
+          } satisfies SpawnResponse);
+        }
+      });
+    });
+  });
+}
+
+async function callDaemon(
+  config: ResolvedOpenSynConfig,
+  toolName: string,
+  argumentsValue: Record<string, unknown>,
+): Promise<unknown> {
+  const request = JSON.stringify({
+    jsonrpc: "2.0",
+    id: Date.now(),
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: argumentsValue,
+    },
+  });
+
+  return new Promise((resolve, reject) => {
+    const timeoutMs = config.daemonTimeoutMs ?? 10_000;
+    const child = spawn(
+      config.daemonBin,
+      ["mcp-stdio", "--db", config.dbPath],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      reject(new Error(`synapse-daemon timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    function finish(fn: () => void) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      fn();
+    }
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      finish(() => {
+        const responseLine = stdout
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean)
+          .at(-1);
+
+        if (code !== 0 && !responseLine) {
+          reject(
+            new Error(
+              `synapse-daemon exited with ${code ?? "unknown"}${stderr ? `: ${stderr.trim()}` : ""}`,
+            ),
+          );
+          return;
+        }
+
+        if (!responseLine) {
+          reject(new Error("synapse-daemon returned no response"));
+          return;
+        }
+
+        try {
+          const response = JSON.parse(responseLine) as RpcResponse;
+          if (response.error?.message) {
+            reject(new Error(response.error.message));
+            return;
+          }
+          resolve(response.result ?? null);
+        } catch (error) {
+          reject(
+            new Error(
+              `failed to parse synapse-daemon response: ${error instanceof Error ? error.message : String(error)}`,
+            ),
+          );
+        }
+      });
+    });
+
+    child.stdin.write(`${request}\n`);
+    child.stdin.end();
+  });
+}
+
+async function runCliCommand(
+  config: ResolvedOpenSynConfig,
+  args: string[],
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const timeoutMs = config.daemonTimeoutMs;
+    const child = spawn(config.cliBin, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      reject(new Error(`synapse-cli timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    function finish(fn: () => void) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      fn();
+    }
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      finish(() => {
+        if (code !== 0) {
+          reject(
+            new Error(
+              `synapse-cli exited with ${code ?? "unknown"}${stderr ? `: ${stderr.trim()}` : ""}`,
+            ),
+          );
+          return;
+        }
+
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+          resolve({ stdout, stderr, exitCode: code } satisfies SpawnResponse);
+          return;
+        }
+
+        try {
+          resolve(JSON.parse(trimmed));
+        } catch {
+          resolve({ stdout, stderr, exitCode: code } satisfies SpawnResponse);
+        }
+      });
+    });
+  });
+}
+
+function asText(result: unknown): { content: ToolContent[] } {
+  const summary = summarizeResult(result);
+  const rendered = summary
+    ? `${summary}\n\nRaw JSON:\n${JSON.stringify(result, null, 2)}`
+    : JSON.stringify(result, null, 2);
+  return {
+    content: [
+      {
+        type: "text",
+        text: rendered,
+      },
+    ],
+  };
+}
+
+function summarizeResult(result: unknown): string {
+  if (result === null) {
+    return "No OpenSyn context was found for this request.";
+  }
+
+  if (Array.isArray(result)) {
+    if (result.length === 0) {
+      return "OpenSyn returned an empty result set.";
+    }
+
+    if (looksLikeSearchHit(result[0])) {
+      return summarizeSearchHits(result as SearchLike[]);
+    }
+
+    if (looksLikeAgentAsset(result[0])) {
+      return summarizeAgentAssets(result as AssetLike[]);
+    }
+
+    if (looksLikeAssetHistoryEntry(result[0])) {
+      return summarizeAssetHistory(result as AssetHistoryLike[]);
+    }
+
+    if (looksLikeDistillationJob(result[0])) {
+      return summarizeDistillationJobs(result as DistillationJobLike[]);
+    }
+
+    if (looksLikeProjectionRecord(result[0])) {
+      return summarizeProjectionRecords(result as ProjectionLike[]);
+    }
+
+    if (looksLikeContextObject(result[0])) {
+      return summarizeEpisodes(result as ContextLike[]);
+    }
+  }
+
+  if (looksLikeContextObject(result)) {
+    return summarizeContextObject(result as ContextLike);
+  }
+
+  if (looksLikeAutonomousCollectionBootstrap(result)) {
+    return summarizeAutonomousCollectionBootstrap(
+      result as {
+        project_root?: string;
+        shell?: string;
+        semantic_hint?: SemanticHint;
+        shell_hook_fix?: unknown;
+        shell_hook_uninstall?: unknown;
+        background_watch?: BackgroundWatchStatus;
+        distillation_worker?: DistillationWorkerStatus;
+        distillation_worker_health?: DistillationWorkerHealth;
+        collection_settings?: CollectionSettingsLike;
+        review_policy?: ReviewPolicySettingsLike;
+        projection_settings?: ProjectionSettingsLike | null;
+        status?: {
+          collection_settings?: CollectionSettingsLike | null;
+          projection_settings?: ProjectionSettingsLike | null;
+        };
+      },
+    );
+  }
+
+  if (looksLikeAutonomousCollectionStatus(result)) {
+    return summarizeAutonomousCollectionStatus(
+      result as {
+        project_root?: string;
+        shell?: string;
+        shell_hook_doctor?: { installed?: boolean; self_test?: { success?: boolean } };
+        shell_capture_health?: ShellCaptureHealth;
+        background_watch?: BackgroundWatchStatus;
+        distillation_worker?: DistillationWorkerStatus;
+        distillation_worker_health?: DistillationWorkerHealth;
+        collection_settings?: CollectionSettingsLike | null;
+        review_policy?: ReviewPolicySettingsLike | null;
+        projection_settings?: ProjectionSettingsLike | null;
+      },
+    );
+  }
+
+  if (looksLikeCollectionSettings(result)) {
+    return summarizeCollectionSettings(result as CollectionSettingsLike);
+  }
+
+  if (looksLikeReviewPolicySettings(result)) {
+    return summarizeReviewPolicySettings(result as ReviewPolicySettingsLike);
+  }
+
+  if (looksLikeDistillationSettings(result)) {
+    return summarizeDistillationSettings(result as DistillationSettingsLike);
+  }
+
+  if (looksLikeDistillationWorkPacket(result)) {
+    return summarizeDistillationWorkPacket(result as DistillationWorkPacketLike);
+  }
+
+  if (looksLikeAutonomousTick(result)) {
+    return summarizeAutonomousTick(result as AutonomousTickLike);
+  }
+
+  if (looksLikeProjectionSettings(result)) {
+    return summarizeProjectionSettings(result as ProjectionSettingsLike);
+  }
+
+  if (looksLikeProjectionSync(result)) {
+    return summarizeProjectionSync(result as ProjectionSyncLike);
+  }
+
+  if (looksLikeRuntimeOverlay(result)) {
+    return summarizeRuntimeOverlay(result as RuntimeOverlayLike);
+  }
+
+  if (looksLikeAssetDiff(result)) {
+    return summarizeAssetDiff(result as AssetDiffLike);
+  }
+
+  if (looksLikeAssetApprovalResult(result)) {
+    return summarizeAssetApprovalResult(
+      result as { asset?: AssetLike; projection_sync?: ProjectionSyncLike },
+    );
+  }
+
+  return "";
+}
+
+function summarizeContextObject(result: ContextLike): string {
+  const hint = result.semantic_hint;
+  const label = result.title || result.summary || hint?.summary_label || "OpenSyn context";
+  const parts = [label];
+
+  if (hint?.activity_kind) {
+    parts.push(`activity=${hint.activity_kind}`);
+  }
+
+  if (hint?.operator_focus) {
+    parts.push(`focus=${hint.operator_focus}`);
+  } else if (result.goal_guess) {
+    parts.push(`focus=${result.goal_guess}`);
+  }
+
+  if (hint?.primary_signature) {
+    parts.push(`signature=${hint.primary_signature}`);
+  }
+
+  if (hint?.primary_artifact) {
+    parts.push(`artifact=${hint.primary_artifact}`);
+  }
+
+  if (result.recent_failures?.length) {
+    parts.push(`recent_failure=${result.recent_failures[0]}`);
+  }
+
+  if (result.recent_changes?.length) {
+    parts.push(`changed_files=${result.recent_changes.length}`);
+  } else if (result.files_touched?.length) {
+    parts.push(`changed_files=${result.files_touched.length}`);
+  }
+
+  if (result.commands?.length) {
+    parts.push(`last_command=${result.commands[0]}`);
+  }
+
+  return parts.join(" | ");
+}
+
+function summarizeEpisodes(results: ContextLike[]): string {
+  const first = results[0];
+  const kind = first.semantic_hint?.activity_kind || "development_activity";
+  return `OpenSyn returned ${results.length} recent episode(s); latest=${first.title || "unknown"} | activity=${kind} | focus=${first.goal_guess || first.semantic_hint?.operator_focus || "review recent activity"}`;
+}
+
+function summarizeSearchHits(results: SearchLike[]): string {
+  const first = results[0];
+  const kind = first.semantic_hint?.activity_kind || "development_activity";
+  const matched = first.semantic_hint?.matched_item_kind || first.item_kind || "unknown";
+  return `OpenSyn returned ${results.length} search hit(s); top_match=${first.title || "unknown"} | activity=${kind} | item=${matched}`;
+}
+
+function summarizeAgentAssets(results: AssetLike[]): string {
+  const first = results[0];
+  const kind = first.semantic_hint?.asset_kind || first.kind || "agent_asset";
+  const status = first.status || first.semantic_hint?.status_label || "unknown";
+  const revision = first.revision ?? first.semantic_hint?.revision ?? 1;
+  return `OpenSyn returned ${results.length} agent asset(s); top_asset=${first.title || "unknown"} | kind=${kind} | status=${status} | revision=${String(revision)}`;
+}
+
+function summarizeAssetHistory(results: AssetHistoryLike[]): string {
+  const first = results[0];
+  const kind = first.asset?.kind || first.asset?.semantic_hint?.asset_kind || "agent_asset";
+  const revision = first.revision ?? first.semantic_hint?.revision ?? 1;
+  return `OpenSyn returned ${results.length} asset history entr${results.length === 1 ? "y" : "ies"}; asset=${first.asset_id || "unknown"} | kind=${kind} | revision=${String(revision)} | change=${first.change_reason || "unknown"}`;
+}
+
+function summarizeAssetDiff(result: AssetDiffLike): string {
+  const changes = [
+    result.title_changed ? "title" : "",
+    result.summary_changed ? "summary" : "",
+    result.content_changed ? "content" : "",
+    (result.added_tags?.length || result.removed_tags?.length) ? "tags" : "",
+  ].filter(Boolean);
+  return `OpenSyn compared asset=${result.asset_id || "unknown"} | revisions=${String(result.from_revision ?? 0)}->${String(result.to_revision ?? 0)} | changed=${changes.join(",") || "none"}`;
+}
+
+function summarizeCollectionSettings(result: CollectionSettingsLike): string {
+  return `OpenSyn collection mode=${result.mode || "unknown"} | auto_distill=${String(result.auto_distill ?? false)} | distill_on_flush=${String(result.distill_on_flush ?? false)}`;
+}
+
+function summarizeReviewPolicySettings(result: ReviewPolicySettingsLike): string {
+  return `OpenSyn review policy | memory=${String(result.auto_approve_memory ?? false)} | skill=${String(result.auto_approve_skill ?? false)} | rule=${String(result.auto_approve_rule ?? false)} | negative_example=${String(result.auto_approve_negative_example ?? false)} | min_confidence=${String(result.min_confidence ?? 0)} | max_revision=${String(result.max_auto_approve_revision ?? "unbounded")} | require_reapproval=${String(result.require_reapproval_on_revision_bump ?? false)}`;
+}
+
+function summarizeDistillationSettings(result: DistillationSettingsLike): string {
+  return `OpenSyn distillation backend=${result.backend || "unknown"} | host_only=${String(result.restricted_to_host_model ?? false)} | allow_network=${String(result.allow_network ?? false)} | auto_enqueue=${String(result.auto_enqueue_on_flush ?? false)} | auto_apply=${String(result.auto_apply_submissions ?? false)}`;
+}
+
+function summarizeDistillationJobs(results: DistillationJobLike[]): string {
+  const first = results[0];
+  return `OpenSyn returned ${results.length} distillation job(s); first_status=${first.status || "unknown"} | first_job=${first.id || "unknown"}`;
+}
+
+function summarizeDistillationWorkPacket(result: DistillationWorkPacketLike): string {
+  const job = result.job;
+  return `OpenSyn distillation work packet | job=${job?.id || "unknown"} | status=${job?.status || "unknown"} | kinds=${String(result.output_spec?.allowed_asset_kinds?.length ?? 0)} | completion_tool=${result.output_spec?.completion_tool || "unknown"} | arg_key=${result.output_spec?.completion_argument_key || "unknown"} | overlay_assets=${String(result.runtime_overlay?.approved_asset_count ?? 0)} | has_executor_prompt=${String(Boolean(result.executor_prompt))}`;
+}
+
+function summarizeAutonomousTick(result: AutonomousTickLike): string {
+  return `OpenSyn autonomous tick | contract=${result.contract_version || "unknown"} | state=${result.automation_state || "unknown"} | transition=${result.transition?.kind || "unknown"} | cycle_primary=${String(result.cycle_plan?.primary_steps?.length ?? 0)} | cycle_fallback=${String(result.cycle_plan?.fallback_steps?.length ?? 0)} | cycle_resume=${String(result.cycle_plan?.resume_steps?.length ?? 0)} | plan_steps=${String(result.execution_plan?.length ?? 0)} | success_tool=${result.transition?.success_action_tool || result.next_action_tool || "none"} | failure_tool=${result.transition?.failure_action_tool || "none"} | resume_tool=${result.transition?.resume_action_tool || "none"} | resume_after_secs=${String(result.transition?.resume_after_secs ?? result.poll_after_secs ?? 0)} | should_continue=${String(result.should_continue ?? false)} | poll_after_secs=${String(result.poll_after_secs ?? 0)} | pending_jobs=${String(result.pending_distillation_jobs ?? 0)} | claimed_job=${result.claimed_job_id || "none"} | overlay_assets=${String(result.runtime_overlay?.approved_asset_count ?? 0)}`;
+}
+
+function summarizeAutonomousCollectionBootstrap(result: {
+  project_root?: string;
+  shell?: string;
+  semantic_hint?: SemanticHint;
+  shell_hook_fix?: unknown;
+  shell_hook_uninstall?: unknown;
+  background_watch?: BackgroundWatchStatus;
+  distillation_worker?: DistillationWorkerStatus;
+  distillation_worker_health?: DistillationWorkerHealth;
+  collection_settings?: CollectionSettingsLike;
+  review_policy?: ReviewPolicySettingsLike;
+  projection_settings?: ProjectionSettingsLike | null;
+  status?: {
+    shell_capture_health?: ShellCaptureHealth;
+    background_watch?: BackgroundWatchStatus;
+    distillation_worker_health?: DistillationWorkerHealth;
+    collection_settings?: CollectionSettingsLike | null;
+    projection_settings?: ProjectionSettingsLike | null;
+  };
+  next_step?: UserNextStep;
+}): string {
+  const statusLabel = result.semantic_hint?.status_label || "updated";
+  const effectiveProjectionSettings = result.projection_settings || result.status?.projection_settings;
+  const projectionEnabled =
+    effectiveProjectionSettings && typeof effectiveProjectionSettings === "object"
+      ? String(effectiveProjectionSettings.enabled ?? false)
+      : "false";
+  const collectionMode =
+    result.collection_settings?.mode ||
+    result.status?.collection_settings?.mode ||
+    "unknown";
+  const distillerHealth =
+    result.distillation_worker_health?.status ||
+    result.status?.distillation_worker_health?.status ||
+    (result.distillation_worker?.last_error
+      ? "error"
+      : result.distillation_worker?.running
+        ? "running"
+        : "stopped");
+  const watcherRunning =
+    result.background_watch?.running ?? result.status?.background_watch?.running ?? false;
+  const nextStep = result.next_step?.code || "none";
+  return `OpenSyn autonomous collection ${statusLabel} | project=${result.project_root || "unknown"} | shell=${result.shell || "unknown"} | watcher=${String(watcherRunning)} | distiller=${distillerHealth} | collection_mode=${collectionMode} | projection=${projectionEnabled} | next=${nextStep}`;
+}
+
+function summarizeAutonomousCollectionStatus(result: {
+  project_root?: string;
+  shell?: string;
+  shell_hook_doctor?: { installed?: boolean; self_test?: { success?: boolean } };
+  shell_capture_health?: ShellCaptureHealth;
+  background_watch?: BackgroundWatchStatus;
+  distillation_worker?: DistillationWorkerStatus;
+  distillation_worker_health?: DistillationWorkerHealth;
+  collection_settings?: CollectionSettingsLike | null;
+  review_policy?: ReviewPolicySettingsLike | null;
+  projection_settings?: ProjectionSettingsLike | null;
+  next_step?: UserNextStep;
+}): string {
+  const shellCapture = result.shell_capture_health?.status || (result.shell_hook_doctor?.installed ? "ready" : "missing");
+  const selfTest = result.shell_hook_doctor?.self_test?.success ?? false;
+  const mode = result.collection_settings?.mode || "unknown";
+  const distillerHealth =
+    result.distillation_worker_health?.status ||
+    (result.distillation_worker?.last_error
+      ? "error"
+      : result.distillation_worker?.running
+        ? "running"
+        : "stopped");
+  const nextStep = result.next_step?.code || "none";
+  return `OpenSyn autonomous status | project=${result.project_root || "unknown"} | command_capture=${shellCapture} | watcher=${String(result.background_watch?.running ?? false)} | distiller=${distillerHealth} | self_test=${String(selfTest)} | collection_mode=${mode} | next=${nextStep}`;
+}
+
+function summarizeProjectionSettings(result: ProjectionSettingsLike): string {
+  return `OpenSyn projection enabled=${String(result.enabled ?? false)} | host=${result.host || "unknown"} | auto_apply_approved=${String(result.auto_apply_approved ?? false)} | target_root=${result.target_root || "unset"}`;
+}
+
+function summarizeProjectionRecords(results: ProjectionLike[]): string {
+  const first = results[0];
+  return `OpenSyn returned ${results.length} projection record(s); asset=${first.asset_id || "unknown"} | status=${first.status || first.semantic_hint?.status_label || "unknown"}`;
+}
+
+function summarizeProjectionSync(result: ProjectionSyncLike): string {
+  return `OpenSyn synced approved assets | host=${result.host || "unknown"} | applied_assets=${String(result.applied_asset_count ?? 0)} | applied_records=${String(result.applied_record_count ?? 0)} | skipped=${String(result.skipped_asset_ids?.length ?? 0)}`;
+}
+
+function summarizeRuntimeOverlay(result: RuntimeOverlayLike): string {
+  const leadFile = result.managed_files?.[0] || "unset";
+  return `OpenSyn runtime overlay | host=${result.host || "unknown"} | approved_assets=${String(result.approved_asset_count ?? 0)} | pending_jobs=${String(result.pending_distillation_jobs ?? 0)} | managed_files=${String(result.managed_files?.length ?? 0)} | skills=${String(result.skills?.length ?? 0)} | lead_file=${leadFile} | target_root=${result.target_root || "unset"}`;
+}
+
+function summarizeAssetApprovalResult(result: {
+  asset?: AssetLike;
+  projection_sync?: ProjectionSyncLike;
+}): string {
+  const asset = result.asset;
+  const sync = result.projection_sync;
+  const revision = asset?.revision ?? asset?.semantic_hint?.revision ?? 1;
+  const base = `OpenSyn approved asset=${asset?.title || "unknown"} | kind=${asset?.kind || asset?.semantic_hint?.asset_kind || "unknown"} | status=${asset?.status || asset?.semantic_hint?.status_label || "approved"} | revision=${String(revision)}`;
+  if (!sync) {
+    return base;
+  }
+  return `${base} | synced_records=${String(sync.applied_record_count ?? 0)} | host=${sync.host || "unknown"}`;
+}
+
+function looksLikeContextObject(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("summary" in result || "title" in result || "goal_guess" in result)
+  );
+}
+
+function looksLikeSearchHit(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("snippet" in result || "item_kind" in result)
+  );
+}
+
+function looksLikeAgentAsset(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("kind" in result || "status" in result)
+  );
+}
+
+function looksLikeAssetHistoryEntry(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("change_reason" in result || "asset_id" in result) &&
+    "asset" in result
+  );
+}
+
+function looksLikeAssetDiff(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("from_revision" in result || "to_revision" in result) &&
+    "asset_id" in result
+  );
+}
+
+function looksLikeCollectionSettings(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("mode" in result || "auto_distill" in result || "distill_on_flush" in result)
+  );
+}
+
+function looksLikeReviewPolicySettings(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("auto_approve_memory" in result ||
+      "auto_approve_skill" in result ||
+      "auto_approve_rule" in result ||
+      "auto_approve_negative_example" in result)
+  );
+}
+
+function looksLikeDistillationSettings(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("backend" in result ||
+      "restricted_to_host_model" in result ||
+      "auto_enqueue_on_flush" in result)
+  );
+}
+
+function looksLikeDistillationJob(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("context_pack_id" in result || "prompt" in result || "submitted_asset_ids" in result)
+  );
+}
+
+function looksLikeDistillationWorkPacket(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "job" in result &&
+    "output_spec" in result
+  );
+}
+
+function looksLikeAutonomousTick(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("action" in result || "claimed_job_id" in result) &&
+    "runtime_overlay" in result
+  );
+}
+
+function looksLikeProjectionSettings(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("enabled" in result || "target_root" in result || "auto_apply_approved" in result)
+  );
+}
+
+function looksLikeProjectionRecord(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("asset_id" in result || "content" in result)
+  );
+}
+
+function looksLikeProjectionSync(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("applied_asset_count" in result || "applied_record_count" in result || "records" in result)
+  );
+}
+
+function looksLikeRuntimeOverlay(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("memory_markdown" in result || "agents_markdown" in result || "managed_files" in result)
+  );
+}
+
+function looksLikeAutonomousCollectionBootstrap(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("shell_hook_fix" in result || "shell_hook_uninstall" in result || "status" in result) &&
+    ("collection_settings" in result || "status" in result)
+  );
+}
+
+function looksLikeAutonomousCollectionStatus(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "shell_hook_doctor" in result &&
+    "collection_settings" in result
+  );
+}
+
+function looksLikeAssetApprovalResult(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("asset" in result || "projection_sync" in result)
+  );
+}
+
+function requireProjectRoot(
+  params: { project_root?: string },
+  config: ResolvedOpenSynConfig,
+): string {
+  return params.project_root || config.defaultProjectRoot || "";
+}
+
+function defaultProjectionRoot(config: ResolvedOpenSynConfig): string {
+  return config.projectionBundleRoot;
+}
+
+function getStoredPluginConfig(api: OpenClawPluginApi): OpenSynConfig {
+  const loaded = (api.runtime.config.loadConfig?.() ?? {}) as Record<string, any>;
+  return (
+    loaded.plugins?.entries?.[PLUGIN_ID]?.config ??
+    (api.pluginConfig ?? {})
+  ) as OpenSynConfig;
+}
+
+function getResolvedPluginConfig(
+  api: OpenClawPluginApi,
+  defaults?: { defaultProjectRoot?: string },
+): ResolvedOpenSynConfig {
+  return resolveOpenSynConfig(getStoredPluginConfig(api), defaults);
+}
+
+async function upsertPluginConfig(
+  api: OpenClawPluginApi,
+  nextConfig: Partial<OpenSynConfig>,
+): Promise<ResolvedOpenSynConfig> {
+  const loaded = (api.runtime.config.loadConfig?.() ?? {}) as Record<string, any>;
+  const plugins = typeof loaded.plugins === "object" && loaded.plugins !== null ? loaded.plugins : {};
+  const entries =
+    typeof plugins.entries === "object" && plugins.entries !== null ? plugins.entries : {};
+  const existingEntry =
+    typeof entries[PLUGIN_ID] === "object" && entries[PLUGIN_ID] !== null ? entries[PLUGIN_ID] : {};
+  const existingConfig =
+    typeof existingEntry.config === "object" && existingEntry.config !== null
+      ? existingEntry.config
+      : {};
+  const allow = Array.isArray(plugins.allow) ? [...plugins.allow] : [];
+  if (!allow.includes(PLUGIN_ID)) {
+    allow.push(PLUGIN_ID);
+  }
+  const mergedConfig = {
+    ...existingConfig,
+    ...nextConfig,
+  };
+  const nextLoaded = {
+    ...loaded,
+    plugins: {
+      ...plugins,
+      allow,
+      entries: {
+        ...entries,
+        [PLUGIN_ID]: {
+          ...existingEntry,
+          enabled: true,
+          config: mergedConfig,
+        },
+      },
+    },
+  };
+  await api.runtime.config.writeConfigFile(nextLoaded);
+  return resolveOpenSynConfig(mergedConfig as OpenSynConfig);
+}
+
+async function enableAutonomousCollection(
+  config: ResolvedOpenSynConfig,
+  params: {
+    project_root: string;
+    shell?: string;
+    auto_approve_memory?: boolean;
+    auto_approve_skill?: boolean;
+    auto_approve_rule?: boolean;
+    auto_approve_negative_example?: boolean;
+    min_confidence?: number;
+    max_auto_approve_revision?: number;
+    require_reapproval_on_revision_bump?: boolean;
+    projection_enabled?: boolean;
+    projection_target_root?: string;
+    projection_host?: string;
+    projection_auto_apply_approved?: boolean;
+    updated_by: string;
+  },
+) {
+  ensureProjectRoot(params.project_root);
+  const shell = params.shell || config.defaultShell || "bash";
+  const shellHookArgs = ["shell-hook-fix", "--db", config.dbPath, "--shell", shell];
+  if (config.helperPath) {
+    shellHookArgs.push("--helper-path", config.helperPath);
+  }
+  if (config.runnerPath) {
+    shellHookArgs.push("--runner-path", config.runnerPath);
+  }
+  shellHookArgs.push("--daemon-bin", config.daemonBin);
+
+  await runCliCommand(config, ["init-db", "--db", config.dbPath]);
+  const shellHookFix = await runDaemonCommand(config, shellHookArgs);
+  const collectionSettings = await callDaemon(config, "set_collection_settings", {
+    project_root: params.project_root,
+    mode: "enabled",
+    auto_distill: true,
+    distill_on_flush: true,
+    updated_by: params.updated_by,
+  });
+  const distillationSettings = await callDaemon(config, "set_distillation_settings", {
+    project_root: params.project_root,
+    backend: "openclaw_host_model",
+    restricted_to_host_model: true,
+    auto_enqueue_on_flush: true,
+    auto_apply_submissions: true,
+    updated_by: params.updated_by,
+  });
+  const reviewPolicy = await callDaemon(config, "set_review_policy_settings", {
+    project_root: params.project_root,
+    auto_approve_memory: params.auto_approve_memory ?? true,
+    auto_approve_skill: params.auto_approve_skill ?? false,
+    auto_approve_rule: params.auto_approve_rule ?? false,
+    auto_approve_negative_example: params.auto_approve_negative_example ?? false,
+    min_confidence: params.min_confidence ?? 0.9,
+    max_auto_approve_revision: params.max_auto_approve_revision ?? 1,
+    require_reapproval_on_revision_bump:
+      params.require_reapproval_on_revision_bump ?? true,
+    updated_by: params.updated_by,
+  });
+
+  let projectionSettings: unknown = null;
+  const projectionTargetRoot = params.projection_target_root || defaultProjectionRoot(config);
+  const projectionEnabled =
+    params.projection_enabled ??
+    Boolean(projectionTargetRoot || config.projectionAutoApplyApproved);
+  if (projectionEnabled && projectionTargetRoot) {
+    projectionSettings = await callDaemon(config, "set_projection_settings", {
+      project_root: params.project_root,
+      enabled: true,
+      host: params.projection_host || config.projectionHost || "openclaw",
+      target_root: projectionTargetRoot,
+      auto_apply_approved:
+        params.projection_auto_apply_approved ??
+        config.projectionAutoApplyApproved ??
+        true,
+      updated_by: params.updated_by,
+    });
+  }
+  const backgroundWatch = await ensureBackgroundWatch(config, params.project_root);
+  const distillationWorker = await ensureDistillationWorker(config, params.project_root);
+  const distillationWorkerHealth = buildDistillationWorkerHealth(distillationWorker);
+  const status = await getAutonomousCollectionStatus(config, {
+    project_root: params.project_root,
+    shell,
+  });
+  const nextStep = buildUserNextStep({
+    collectionMode:
+      (status.collection_settings as CollectionSettingsLike | undefined)?.mode || "enabled",
+    backgroundWatch: status.background_watch as BackgroundWatchStatus | undefined,
+    shellCaptureHealth: status.shell_capture_health as ShellCaptureHealth | undefined,
+    distillationWorkerHealth:
+      status.distillation_worker_health as DistillationWorkerHealth | undefined,
+  });
+
+  return {
+    semantic_hint: {
+      activity_kind: "autonomous_collection_bootstrap",
+      status_label: "enabled",
+      operator_focus:
+        "OpenSyn installed shell-hook capture and enabled automatic collection, review, and projection defaults.",
+    },
+    project_root: params.project_root,
+    shell,
+    shell_hook_fix: shellHookFix,
+    background_watch: backgroundWatch,
+    distillation_worker: distillationWorker,
+    distillation_worker_health: distillationWorkerHealth,
+    collection_settings: collectionSettings,
+    distillation_settings: distillationSettings,
+    review_policy: reviewPolicy,
+    projection_settings: projectionSettings,
+    status,
+    next_step: nextStep,
+  };
+}
+
+async function getAutonomousCollectionStatus(
+  config: ResolvedOpenSynConfig,
+  params: { project_root: string; shell?: string },
+) {
+  const shell = params.shell || config.defaultShell || "bash";
+  const doctorArgs = ["shell-hook-doctor", "--db", config.dbPath, "--shell", shell];
+  if (config.helperPath) {
+    doctorArgs.push("--helper-path", config.helperPath);
+  }
+  if (config.runnerPath) {
+    doctorArgs.push("--runner-path", config.runnerPath);
+  }
+  doctorArgs.push("--daemon-bin", config.daemonBin);
+
+  const shellHookDoctor = await runDaemonCommand(config, doctorArgs);
+  const shellCaptureHealth = buildShellCaptureHealth(shellHookDoctor as ShellHookDoctorLike);
+  const collectionSettings = await callDaemon(config, "get_collection_settings", {
+    project_root: params.project_root,
+  });
+  const distillationSettings = await callDaemon(config, "get_distillation_settings", {
+    project_root: params.project_root,
+  });
+  const reviewPolicy = await callDaemon(config, "get_review_policy_settings", {
+    project_root: params.project_root,
+  });
+  const projectionSettings = await callDaemon(config, "get_projection_settings", {
+    project_root: params.project_root,
+  });
+  const backgroundWatch = getBackgroundWatchStatus(config, params.project_root);
+  const distillationWorker = getDistillationWorkerStatus(config, params.project_root);
+  const distillationWorkerHealth = buildDistillationWorkerHealth(distillationWorker);
+  const nextStep = buildUserNextStep({
+    collectionMode: (collectionSettings as CollectionSettingsLike | undefined)?.mode,
+    backgroundWatch,
+    shellCaptureHealth,
+    distillationWorkerHealth,
+  });
+
+  return {
+    semantic_hint: {
+      activity_kind: "autonomous_collection_status",
+      status_label: "inspected",
+      operator_focus:
+        "Review shell-hook health and the current collection, review, and projection settings.",
+    },
+    project_root: params.project_root,
+    shell,
+    shell_hook_doctor: shellHookDoctor,
+    shell_capture_health: shellCaptureHealth,
+    background_watch: backgroundWatch,
+    distillation_worker: distillationWorker,
+    distillation_worker_health: distillationWorkerHealth,
+    collection_settings: collectionSettings,
+    distillation_settings: distillationSettings,
+    review_policy: reviewPolicy,
+    projection_settings: projectionSettings,
+    next_step: nextStep,
+  };
+}
+
+async function disableAutonomousCollection(
+  config: ResolvedOpenSynConfig,
+  params: { project_root: string; shell?: string; updated_by: string },
+) {
+  const shell = params.shell || config.defaultShell || "bash";
+  const shellHookUninstall = await runDaemonCommand(config, [
+    "uninstall-shell-hook",
+    "--shell",
+    shell,
+  ]);
+  const collectionSettings = await callDaemon(config, "set_collection_settings", {
+    project_root: params.project_root,
+    mode: "disabled",
+    auto_distill: false,
+    distill_on_flush: false,
+    updated_by: params.updated_by,
+  });
+  const distillationSettings = await callDaemon(config, "set_distillation_settings", {
+    project_root: params.project_root,
+    backend: "openclaw_host_model",
+    restricted_to_host_model: true,
+    auto_enqueue_on_flush: false,
+    auto_apply_submissions: false,
+    updated_by: params.updated_by,
+  });
+  const backgroundWatch = stopBackgroundWatch(config, params.project_root);
+  const distillationWorker = stopDistillationWorker(config, params.project_root);
+  const distillationWorkerHealth = buildDistillationWorkerHealth(distillationWorker);
+  const nextStep = buildUserNextStep({
+    collectionMode: "disabled",
+    backgroundWatch,
+    distillationWorkerHealth,
+  });
+
+  return {
+    semantic_hint: {
+      activity_kind: "autonomous_collection_bootstrap",
+      status_label: "disabled",
+      operator_focus:
+        "OpenSyn removed persistent shell-hook collection and disabled background distillation for this project.",
+    },
+    project_root: params.project_root,
+    shell,
+    shell_hook_uninstall: shellHookUninstall,
+    background_watch: backgroundWatch,
+    distillation_worker: distillationWorker,
+    distillation_worker_health: distillationWorkerHealth,
+    collection_settings: collectionSettings,
+    distillation_settings: distillationSettings,
+    next_step: nextStep,
+  };
+}
+
+async function repairAutonomousCollection(
+  config: ResolvedOpenSynConfig,
+  params: { project_root: string; shell?: string },
+) {
+  ensureProjectRoot(params.project_root);
+  const shell = params.shell || config.defaultShell || "bash";
+  await runCliCommand(config, ["init-db", "--db", config.dbPath]);
+  const shellHookArgs = ["shell-hook-fix", "--db", config.dbPath, "--shell", shell];
+  if (config.helperPath) {
+    shellHookArgs.push("--helper-path", config.helperPath);
+  }
+  if (config.runnerPath) {
+    shellHookArgs.push("--runner-path", config.runnerPath);
+  }
+  shellHookArgs.push("--daemon-bin", config.daemonBin);
+
+  const shellHookFix = await runDaemonCommand(config, shellHookArgs);
+  const backgroundWatch = await ensureBackgroundWatch(config, params.project_root);
+  const distillationWorker = await ensureDistillationWorker(config, params.project_root);
+  const distillationWorkerHealth = buildDistillationWorkerHealth(distillationWorker);
+  const status = await getAutonomousCollectionStatus(config, {
+    project_root: params.project_root,
+    shell,
+  });
+  const nextStep = buildUserNextStep({
+    collectionMode:
+      (status.collection_settings as CollectionSettingsLike | undefined)?.mode || "enabled",
+    backgroundWatch: status.background_watch as BackgroundWatchStatus | undefined,
+    shellCaptureHealth: status.shell_capture_health as ShellCaptureHealth | undefined,
+    distillationWorkerHealth:
+      status.distillation_worker_health as DistillationWorkerHealth | undefined,
+  });
+
+  return {
+    semantic_hint: {
+      activity_kind: "autonomous_collection_bootstrap",
+      status_label: "repaired",
+      operator_focus:
+        "OpenSyn refreshed the managed runtime, repaired the shell hook, and rechecked autonomous collection health.",
+    },
+    project_root: params.project_root,
+    shell,
+    shell_hook_fix: shellHookFix,
+    background_watch: backgroundWatch,
+    distillation_worker: distillationWorker,
+    distillation_worker_health: distillationWorkerHealth,
+    status,
+    next_step: nextStep,
+  };
+}
+
+function printCliResult(result: unknown): void {
+  const summary = summarizeResult(result);
+  if (summary) {
+    console.log(summary);
+  }
+  console.log(JSON.stringify(result, null, 2));
+}
+
+export default {
+  id: PLUGIN_ID,
+  name: "OpenSyn",
+  description: "Bridge local OpenSyn context into OpenClaw native plugin tools.",
+  register(api: OpenClawPluginApi) {
+    const config = getResolvedPluginConfig(api);
+
+    api.registerCli(
+      ({ program, workspaceDir }) => {
+        const resolveCliProjectRoot = (input?: string): string =>
+          path.resolve(input || workspaceDir || process.cwd());
+
+        const resolveCliConfig = async (
+          projectRoot?: string,
+          persist = false,
+        ) => {
+          const stored = getStoredPluginConfig(api);
+          const resolved = resolveOpenSynConfig(
+            {
+              ...stored,
+              defaultProjectRoot: stored.defaultProjectRoot || projectRoot,
+            },
+            { defaultProjectRoot: projectRoot },
+          );
+          if (!persist) {
+            return resolved;
+          }
+          const persisted = await upsertPluginConfig(api, resolved);
+          Object.assign(config, persisted);
+          return persisted;
+        };
+
+        program
+          .command("enable_opensyn")
+          .description(
+            "Enable OpenSyn background collection, secure host-model distillation, and host projection for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to manage for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await enableAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+              updated_by: "openclaw_cli",
+            });
+            printCliResult(result);
+          });
+
+        program
+          .command("disable_opensyn")
+          .description(
+            "Disable OpenSyn background collection for the current workspace and remove the managed shell hook.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to stop managing for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await disableAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+              updated_by: "openclaw_cli",
+            });
+            printCliResult(result);
+          });
+
+        program
+          .command("status_opensyn")
+          .description(
+            "Alias for openclaw opensyn_status.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to inspect for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getAutonomousCollectionStatus(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        program
+          .command("opensyn_status")
+          .description(
+            "Show OpenSyn autonomous collection status for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to inspect for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getAutonomousCollectionStatus(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        program
+          .command("doctor_opensyn")
+          .description(
+            "Inspect OpenSyn runtime, shell-hook, and collection health for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to inspect for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getAutonomousCollectionStatus(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        program
+          .command("repair_opensyn")
+          .description(
+            "Repair OpenSyn local runtime assets, refresh the managed shell hook, and re-check health for the current workspace.",
+          )
+          .argument(
+            "[project_root]",
+            "Optional project root. Defaults to the current OpenClaw workspace.",
+          )
+          .option("--shell <shell>", "Shell to repair for command capture.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await repairAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        const opensyn = program
+          .command("opensyn")
+          .description("OpenSyn management commands.");
+
+        opensyn
+          .command("enable")
+          .description("Alias for openclaw enable_opensyn.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await enableAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+              updated_by: "openclaw_cli",
+            });
+            printCliResult(result);
+          });
+
+        opensyn
+          .command("disable")
+          .description("Alias for openclaw disable_opensyn.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await disableAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+              updated_by: "openclaw_cli",
+            });
+            printCliResult(result);
+          });
+
+        opensyn
+          .command("status")
+          .description("Alias for openclaw status_opensyn.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getAutonomousCollectionStatus(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        opensyn
+          .command("doctor")
+          .description("Alias for openclaw doctor_opensyn.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getAutonomousCollectionStatus(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+
+        opensyn
+          .command("repair")
+          .description("Repair OpenSyn runtime and refresh the managed shell hook.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .action(async (projectRootArg?: string, opts?: { shell?: string }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot, true);
+            const result = await repairAutonomousCollection(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result);
+          });
+      },
+      {
+        commands: [
+          "enable_opensyn",
+          "disable_opensyn",
+          "status_opensyn",
+          "opensyn_status",
+          "doctor_opensyn",
+          "repair_opensyn",
+          "opensyn",
+        ],
+      },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_recent_failure",
+        description:
+          "Return the most recent OpenSyn build failure context. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_recent_build_failure", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_current_context",
+        description:
+          "Synthesize current OpenSyn context from recent raw events. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          window_secs: Type.Optional(Type.Integer({ minimum: 1 })),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; window_secs?: number; limit?: number },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "synthesize_recent_activity", {
+            project_root: projectRoot,
+            window_secs: params.window_secs ?? config.defaultWindowSecs ?? 300,
+            limit: params.limit ?? 512,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_recent_android_debug",
+        description:
+          "Return the most recent Android debug context. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_recent_android_debug_context", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_search_history",
+        description:
+          "Search OpenSyn task episodes and context packs. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          query: Type.String(),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; query: string; limit?: number },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "search_project_history", {
+            project_root: projectRoot,
+            query: params.query,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_distill_assets",
+        description:
+          "Distill candidate memory/skill/rule assets for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; limit?: number },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "distill_agent_assets", {
+            project_root: projectRoot,
+            limit: params.limit ?? 5,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_list_assets",
+        description:
+          "List stored agent assets such as memory, skill, and rule candidates. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          kind: Type.Optional(
+            Type.String({
+              description:
+                "Optional asset kind filter: memory, skill, rule, role, preference, negative_example, soul.",
+            }),
+          ),
+          status: Type.Optional(
+            Type.String({
+              description:
+                "Optional asset status filter: candidate, approved, rejected, archived.",
+            }),
+          ),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            kind?: string;
+            status?: string;
+            limit?: number;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "list_agent_assets", {
+            project_root: projectRoot,
+            kind: params.kind,
+            status: params.status,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_list_asset_history",
+        description:
+          "List revision history for one asset or one lineage. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          asset_id: Type.Optional(Type.String()),
+          lineage_key: Type.Optional(Type.String()),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            asset_id?: string;
+            lineage_key?: string;
+            limit?: number;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "list_agent_asset_history", {
+            project_root: projectRoot,
+            asset_id: params.asset_id,
+            lineage_key: params.lineage_key,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_diff_asset_revisions",
+        description:
+          "Compare two revisions of the same asset so the agent can review what changed before approving or rolling back.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+          from_revision: Type.Integer({ minimum: 1 }),
+          to_revision: Type.Integer({ minimum: 1 }),
+        }),
+        async execute(
+          _id,
+          params: { asset_id: string; from_revision: number; to_revision: number },
+        ) {
+          const result = await callDaemon(config, "diff_agent_asset_revisions", {
+            asset_id: params.asset_id,
+            from_revision: params.from_revision,
+            to_revision: params.to_revision,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_enable_autonomous_collection",
+        description:
+          "Bootstrap plugin-managed OpenSyn collection on this machine: install or refresh the shell hook, enable automatic distillation, and configure cautious review/projection defaults for the current project.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          shell: Type.Optional(
+            Type.String({
+              description:
+                "Shell to configure for persistent command collection, for example bash or zsh.",
+            }),
+          ),
+          auto_approve_memory: Type.Optional(Type.Boolean()),
+          auto_approve_skill: Type.Optional(Type.Boolean()),
+          auto_approve_rule: Type.Optional(Type.Boolean()),
+          auto_approve_negative_example: Type.Optional(Type.Boolean()),
+          min_confidence: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+          max_auto_approve_revision: Type.Optional(Type.Integer({ minimum: 1 })),
+          require_reapproval_on_revision_bump: Type.Optional(Type.Boolean()),
+          projection_enabled: Type.Optional(Type.Boolean()),
+          projection_target_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional projection root. Leave unset to use projectionBundleRoot from plugin config.",
+            }),
+          ),
+          projection_host: Type.Optional(
+            Type.String({
+              description:
+                "Optional projection host: openclaw, claude_code, or generic. Leave unset to use projectionHost from plugin config.",
+            }),
+          ),
+          projection_auto_apply_approved: Type.Optional(Type.Boolean()),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            shell?: string;
+            auto_approve_memory?: boolean;
+            auto_approve_skill?: boolean;
+            auto_approve_rule?: boolean;
+            auto_approve_negative_example?: boolean;
+            min_confidence?: number;
+            max_auto_approve_revision?: number;
+            require_reapproval_on_revision_bump?: boolean;
+            projection_enabled?: boolean;
+            projection_target_root?: string;
+            projection_host?: string;
+            projection_auto_apply_approved?: boolean;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await enableAutonomousCollection(config, {
+            project_root: projectRoot,
+            shell: params.shell,
+            auto_approve_memory: params.auto_approve_memory,
+            auto_approve_skill: params.auto_approve_skill,
+            auto_approve_rule: params.auto_approve_rule,
+            auto_approve_negative_example: params.auto_approve_negative_example,
+            min_confidence: params.min_confidence,
+            max_auto_approve_revision: params.max_auto_approve_revision,
+            require_reapproval_on_revision_bump:
+              params.require_reapproval_on_revision_bump,
+            projection_enabled: params.projection_enabled,
+            projection_target_root: params.projection_target_root,
+            projection_host: params.projection_host,
+            projection_auto_apply_approved: params.projection_auto_apply_approved,
+            updated_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_autonomous_collection_status",
+        description:
+          "Inspect plugin-managed OpenSyn collection on this machine: shell hook health plus collection, review, and projection settings for the current project.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          shell: Type.Optional(
+            Type.String({
+              description:
+                "Shell to inspect for persistent command collection, for example bash or zsh.",
+            }),
+          ),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            shell?: string;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await getAutonomousCollectionStatus(config, {
+            project_root: projectRoot,
+            shell: params.shell,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_get_collection_mode",
+        description:
+          "Read OpenSyn collection-mode settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_collection_settings", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_get_review_policy",
+        description:
+          "Read OpenSyn review-policy settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_review_policy_settings", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_get_distillation_mode",
+        description:
+          "Read OpenSyn secure distillation settings for the current project. This is the control surface that decides whether distillation stays local or is restricted to the OpenClaw host model.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_distillation_settings", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_set_distillation_mode",
+        description:
+          "Set secure distillation settings for the current project. Recommended mode is openclaw_host_model with host-only restrictions and no network access.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          backend: Type.Optional(
+            Type.String({
+              description:
+                "Distillation backend: openclaw_host_model or local_heuristic.",
+            }),
+          ),
+          restricted_to_host_model: Type.Optional(Type.Boolean()),
+          auto_enqueue_on_flush: Type.Optional(Type.Boolean()),
+          auto_apply_submissions: Type.Optional(Type.Boolean()),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            backend?: string;
+            restricted_to_host_model?: boolean;
+            auto_enqueue_on_flush?: boolean;
+            auto_apply_submissions?: boolean;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "set_distillation_settings", {
+            project_root: projectRoot,
+            backend: params.backend ?? "openclaw_host_model",
+            restricted_to_host_model: params.restricted_to_host_model ?? true,
+            auto_enqueue_on_flush: params.auto_enqueue_on_flush ?? true,
+            auto_apply_submissions: params.auto_apply_submissions ?? true,
+            updated_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_set_review_policy",
+        description:
+          "Set OpenSyn review-policy settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          auto_approve_memory: Type.Optional(Type.Boolean()),
+          auto_approve_skill: Type.Optional(Type.Boolean()),
+          auto_approve_rule: Type.Optional(Type.Boolean()),
+          auto_approve_negative_example: Type.Optional(Type.Boolean()),
+          min_confidence: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+          max_auto_approve_revision: Type.Optional(Type.Integer({ minimum: 1 })),
+          require_reapproval_on_revision_bump: Type.Optional(Type.Boolean()),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            auto_approve_memory?: boolean;
+            auto_approve_skill?: boolean;
+            auto_approve_rule?: boolean;
+            auto_approve_negative_example?: boolean;
+            min_confidence?: number;
+            max_auto_approve_revision?: number;
+            require_reapproval_on_revision_bump?: boolean;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "set_review_policy_settings", {
+            project_root: projectRoot,
+            auto_approve_memory: params.auto_approve_memory,
+            auto_approve_skill: params.auto_approve_skill,
+            auto_approve_rule: params.auto_approve_rule,
+            auto_approve_negative_example: params.auto_approve_negative_example,
+            min_confidence: params.min_confidence,
+            max_auto_approve_revision: params.max_auto_approve_revision,
+            require_reapproval_on_revision_bump:
+              params.require_reapproval_on_revision_bump,
+            updated_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_list_distillation_jobs",
+        description:
+          "List queued host-model distillation jobs for the current project. These jobs contain the grounded prompt that should be consumed only by the OpenClaw-configured model.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          status: Type.Optional(
+            Type.String({
+              description:
+                "Optional status filter: pending, submitted, completed, cancelled.",
+            }),
+          ),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; status?: string; limit?: number },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "list_distillation_jobs", {
+            project_root: projectRoot,
+            status: params.status,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_autonomous_tick",
+        description:
+          "Single polling entry-point for OpenSyn host automation. Returns either the next distillation work packet to process or an idle runtime state when there is no queued work.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "autonomous_tick", {
+            project_root: projectRoot,
+            claimed_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_next_distillation_job",
+        description:
+          "Fetch the next pending host-model distillation job for the current project so the OpenClaw-configured model can process one job at a time.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_next_distillation_job", {
+            project_root: projectRoot,
+            claimed_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_next_distillation_packet",
+        description:
+          "Claim the next queued host-model distillation task and return a single work packet containing the prompt, output schema, review policy, current runtime overlay, and the completion tool to call next.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_next_distillation_work_packet", {
+            project_root: projectRoot,
+            claimed_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_submit_distillation_job",
+        description:
+          "Submit host-model distilled assets for a queued job. Use only the current OpenClaw-configured model and only the evidence provided in the queued job prompt.",
+        parameters: Type.Object({
+          job_id: Type.String(),
+          assets: Type.Array(
+            Type.Object({
+              kind: Type.String(),
+              title: Type.String(),
+              summary: Type.String(),
+              content: Type.String(),
+              tags: Type.Optional(Type.Array(Type.String())),
+              confidence: Type.Number({ minimum: 0, maximum: 1 }),
+              lineage_key: Type.Optional(Type.String()),
+              projection_targets: Type.Optional(Type.Array(Type.String())),
+            }),
+          ),
+        }),
+        async execute(
+          _id,
+          params: {
+            job_id: string;
+            assets: Array<{
+              kind: string;
+              title: string;
+              summary: string;
+              content: string;
+              tags?: string[];
+              confidence: number;
+              lineage_key?: string;
+              projection_targets?: string[];
+            }>;
+          },
+        ) {
+          const result = await callDaemon(config, "submit_distillation_job_result", {
+            job_id: params.job_id,
+            assets: params.assets,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_complete_next_distillation_job",
+        description:
+          "Submit distilled assets for the next pending host-model job for the current project, so the agent does not need to carry the job_id manually.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          assets: Type.Array(
+            Type.Object({
+              kind: Type.String(),
+              title: Type.String(),
+              summary: Type.String(),
+              content: Type.String(),
+              tags: Type.Optional(Type.Array(Type.String())),
+              confidence: Type.Number({ minimum: 0, maximum: 1 }),
+              lineage_key: Type.Optional(Type.String()),
+              projection_targets: Type.Optional(Type.Array(Type.String())),
+            }),
+          ),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            assets: Array<{
+              kind: string;
+              title: string;
+              summary: string;
+              content: string;
+              tags?: string[];
+              confidence: number;
+              lineage_key?: string;
+              projection_targets?: string[];
+            }>;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "complete_next_distillation_job", {
+            project_root: projectRoot,
+            claimed_by: "openclaw_plugin",
+            assets: params.assets,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_requeue_distillation_job",
+        description:
+          "Put a claimed host-model distillation job back into the pending queue if the current turn cannot finish it safely.",
+        parameters: Type.Object({
+          job_id: Type.String(),
+        }),
+        async execute(_id, params: { job_id: string }) {
+          const result = await callDaemon(config, "requeue_distillation_job", {
+            job_id: params.job_id,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_set_collection_mode",
+        description:
+          "Set OpenSyn collection-mode settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          mode: Type.String({
+            description: "Collection mode: enabled or disabled.",
+          }),
+          auto_distill: Type.Optional(Type.Boolean()),
+          distill_on_flush: Type.Optional(Type.Boolean()),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            mode: string;
+            auto_distill?: boolean;
+            distill_on_flush?: boolean;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "set_collection_settings", {
+            project_root: projectRoot,
+            mode: params.mode,
+            auto_distill: params.auto_distill,
+            distill_on_flush: params.distill_on_flush,
+            updated_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_approve_asset",
+        description:
+          "Approve an OpenSyn agent asset candidate. If projection mode is configured with auto_apply_approved, the asset will also be synced immediately.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+        }),
+        async execute(_id, params: { asset_id: string }) {
+          const result = await callDaemon(config, "approve_agent_asset", {
+            asset_id: params.asset_id,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_get_projection_mode",
+        description:
+          "Read OpenSyn projection-mode settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_projection_settings", {
+            project_root: projectRoot,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_set_projection_mode",
+        description:
+          "Set OpenSyn projection-mode settings for the current project. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          enabled: Type.Optional(Type.Boolean()),
+          target_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional projection target root. Leave unset to use projectionBundleRoot from plugin config.",
+            }),
+          ),
+          host: Type.Optional(
+            Type.String({
+              description:
+                "Optional host type: openclaw, claude_code, or generic. Leave unset to use projectionHost from plugin config.",
+            }),
+          ),
+          auto_apply_approved: Type.Optional(Type.Boolean()),
+        }),
+        async execute(
+          _id,
+          params: {
+            project_root?: string;
+            enabled?: boolean;
+            target_root?: string;
+            host?: string;
+            auto_apply_approved?: boolean;
+          },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const targetRoot = params.target_root || config.projectionBundleRoot;
+          const effectiveTargetRoot = targetRoot || defaultProjectionRoot(config);
+          if (!effectiveTargetRoot) {
+            throw new Error("target_root is required unless projectionBundleRoot is configured or the OpenClaw workspace default is available");
+          }
+          const result = await callDaemon(config, "set_projection_settings", {
+            project_root: projectRoot,
+            enabled: params.enabled ?? true,
+            target_root: effectiveTargetRoot,
+            host: params.host || config.projectionHost || "openclaw",
+            auto_apply_approved:
+              params.auto_apply_approved ?? config.projectionAutoApplyApproved ?? false,
+            updated_by: "openclaw_plugin",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_agent_runtime_overlay",
+        description:
+          "Return the aggregated OpenClaw runtime overlay built from approved assets. This is the closest current view of what OpenClaw should consume as memory, rules, soul, and skills.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          host: Type.Optional(
+            Type.String({
+              description:
+                "Optional host override: openclaw, claude_code, or generic. Leave unset to use projectionHost or the stored projection settings.",
+            }),
+          ),
+        }),
+        async execute(_id, params: { project_root?: string; host?: string }) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "get_agent_runtime_overlay", {
+            project_root: projectRoot,
+            host: params.host || config.projectionHost || "openclaw",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_reject_asset",
+        description:
+          "Reject an OpenSyn agent asset candidate so it will not be projected.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+        }),
+        async execute(_id, params: { asset_id: string }) {
+          const result = await callDaemon(config, "reject_agent_asset", {
+            asset_id: params.asset_id,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_rollback_asset_revision",
+        description:
+          "Restore the current asset from one recorded revision of the same asset lineage.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+          revision: Type.Integer({ minimum: 1 }),
+        }),
+        async execute(_id, params: { asset_id: string; revision: number }) {
+          const result = await callDaemon(config, "rollback_agent_asset_revision", {
+            asset_id: params.asset_id,
+            revision: params.revision,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_project_asset",
+        description:
+          "Build projection previews for an approved asset so OpenClaw can inspect what would be written back into the host.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+        }),
+        async execute(_id, params: { asset_id: string }) {
+          const result = await callDaemon(config, "project_agent_asset", {
+            asset_id: params.asset_id,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_list_projections",
+        description:
+          "List recent projection records for the current project or for one asset. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          asset_id: Type.Optional(Type.String()),
+          limit: Type.Optional(Type.Integer({ minimum: 1 })),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; asset_id?: string; limit?: number },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "list_projection_records", {
+            project_root: projectRoot,
+            asset_id: params.asset_id,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_apply_asset_projection",
+        description:
+          "Apply one approved asset using stored projection settings or the configured target root. In OpenClaw host mode this updates managed sections in the OpenClaw workspace; other hosts still use bundle-style output.",
+        parameters: Type.Object({
+          asset_id: Type.String(),
+          bundle_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional projection bundle root. Leave unset to use projectionBundleRoot from plugin config.",
+            }),
+          ),
+        }),
+        async execute(
+          _id,
+          params: { asset_id: string; bundle_root?: string },
+        ) {
+          const bundleRoot = params.bundle_root || defaultProjectionRoot(config);
+          if (!bundleRoot) {
+            throw new Error("bundle_root is required unless projectionBundleRoot is configured or the OpenClaw workspace default is available");
+          }
+          const result = await callDaemon(config, "apply_asset_projection_bundle", {
+            asset_id: params.asset_id,
+            bundle_root: bundleRoot,
+            host: config.projectionHost || "openclaw",
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_sync_assets",
+        description:
+          "Apply all approved assets for the current project using stored projection settings. In OpenClaw host mode this syncs the managed workspace overlay. Omit project_root to use defaultProjectRoot from plugin config.",
+        parameters: Type.Object({
+          project_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional absolute project root. Leave unset to use defaultProjectRoot from plugin config.",
+            }),
+          ),
+          target_root: Type.Optional(
+            Type.String({
+              description:
+                "Optional target root override. Leave unset to use stored projection settings or projectionBundleRoot from plugin config.",
+            }),
+          ),
+          host: Type.Optional(
+            Type.String({
+              description:
+                "Optional host override. Leave unset to use stored projection settings or projectionHost from plugin config.",
+            }),
+          ),
+        }),
+        async execute(
+          _id,
+          params: { project_root?: string; target_root?: string; host?: string },
+        ) {
+          const projectRoot = requireProjectRoot(params, config);
+          if (!projectRoot) {
+            throw new Error("project_root is required unless defaultProjectRoot is configured");
+          }
+          const result = await callDaemon(config, "sync_approved_assets", {
+            project_root: projectRoot,
+            target_root: params.target_root || defaultProjectionRoot(config),
+            host: params.host || config.projectionHost,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+  },
+};