opensyn 0.1.3 → 0.1.5

package/index.ts

@@ -10,7 +10,6 @@ import {
   readFileSync,
   readdirSync,
   renameSync,
-  realpathSync,
   rmSync,
   statSync,
   writeFileSync,
@@ -19,7 +18,7 @@ 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";
+import type { OpenClawPluginApi, OpenClawPluginServiceContext } from "openclaw/plugin-sdk";
 
 type ToolContent = { type: "text"; text: string };
 
@@ -122,6 +121,14 @@ type DistillationSettingsLike = {
   semantic_hint?: SemanticHint;
 };
 
+type AuditStatsLike = {
+  raw_event_count?: number;
+  context_pack_count?: number;
+  task_episode_count?: number;
+  agent_asset_count?: number;
+  projects?: string[];
+};
+
 type DistillationJobLike = {
   id?: string;
   project_root?: string;
@@ -264,7 +271,7 @@ type DistillationWorkerStatus = {
   enabled: boolean;
   running: boolean;
   pid?: number;
-  source: "openclaw_host_model_agent";
+  source: "openclaw_host_model_agent" | "openclaw_host_model_service";
   project_root: string;
   state_path: string;
   log_path: string;
@@ -411,37 +418,20 @@ function ensureProjectRoot(projectRoot: string): void {
 }
 
 function defaultDbPath(): string {
-  const home = process.env.HOME || os.homedir();
+  const home = os.homedir();
   return path.join(home, ".opensyn", "opensyn.db");
 }
 
 function defaultRuntimeRoot(): string {
-  const home = process.env.HOME || os.homedir();
+  const home = os.homedir();
   return path.join(home, ".opensyn");
 }
 
 function defaultShell(): string {
-  return path.basename(process.env.SHELL || "bash") || "bash";
+  return "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";
 }
 
@@ -453,7 +443,7 @@ function stableNodeRunner(): string {
 }
 
 function defaultProjectionBundleRoot(): string {
-  const home = process.env.HOME || os.homedir();
+  const home = os.homedir();
   return path.join(home, ".openclaw", "workspace");
 }
 
@@ -505,7 +495,6 @@ function resolveOpenSynConfig(
   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"),
@@ -514,7 +503,6 @@ function resolveOpenSynConfig(
 
   const cliBin = resolvePreferredPath([
     config.cliBin,
-    process.env.OPENSYN_CLI_BIN,
     path.join(managedRuntimeDir, "opensyn-cli"),
     packageRuntimePath("opensyn-cli"),
     repoFallbackPath("target", "debug", "synapse-cli"),
@@ -588,6 +576,37 @@ function distillationWorkerLogPath(
   return path.join(backgroundWatchDir(config, projectRoot), "host-distiller.log");
 }
 
+function appendLogLine(logPath: string, message: string): void {
+  mkdirSync(path.dirname(logPath), { recursive: true });
+  writeFileSync(logPath, `${message.trimEnd()}\n`, { encoding: "utf8", flag: "a" });
+}
+
+function updateJsonStateFile(statePath: string, payload: Record<string, unknown>): void {
+  const previous = readJsonFile<Record<string, unknown>>(statePath) ?? {};
+  mkdirSync(path.dirname(statePath), { recursive: true });
+  writeFileSync(
+    statePath,
+    `${JSON.stringify({ ...previous, ...payload }, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+function parseIsoTimestamp(value: unknown): number | null {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function isRecentIsoTimestamp(value: unknown, maxAgeMs: number): boolean {
+  const parsed = parseIsoTimestamp(value);
+  if (parsed === null) {
+    return false;
+  }
+  return Date.now() - parsed <= maxAgeMs;
+}
+
 function isPidAlive(pid?: number): boolean {
   if (!pid || pid <= 0) {
     return false;
@@ -709,23 +728,45 @@ function getDistillationWorkerStatus(
   const logPath = distillationWorkerLogPath(config, projectRoot);
   const state = readJsonFile<{
     pid?: number;
+    manager_pid?: number;
+    runtime?: string;
+    service_heartbeat_at?: string;
+    interval_secs?: number;
     last_exit_code?: number | null;
     last_error?: string;
     last_finished_at?: string;
   }>(statePath);
-  const pid = state?.pid;
+  const runtime =
+    state?.runtime === "openclaw_plugin_service"
+      ? state.runtime
+      : state?.runtime === "legacy" || typeof state?.pid === "number"
+        ? "legacy"
+        : "openclaw_plugin_service";
+  const pid = runtime === "openclaw_plugin_service" ? state?.manager_pid : state?.pid;
+  const intervalSecs =
+    typeof state?.interval_secs === "number" && Number.isFinite(state.interval_secs)
+      ? Math.max(5, Math.trunc(state.interval_secs))
+      : config.distillationWorkerIntervalSecs;
+  const serviceHealthy =
+    runtime === "openclaw_plugin_service" &&
+    isRecentIsoTimestamp(state?.service_heartbeat_at, Math.max(30_000, intervalSecs * 3_000));
   return {
     supported: true,
     enabled: config.distillationWorkerEnabled,
-    running: config.distillationWorkerEnabled && isPidAlive(pid),
+    running:
+      config.distillationWorkerEnabled &&
+      (runtime === "openclaw_plugin_service" ? serviceHealthy : isPidAlive(pid)),
     pid,
-    source: "openclaw_host_model_agent",
+    source:
+      runtime === "openclaw_plugin_service"
+        ? "openclaw_host_model_service"
+        : "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,
+    interval_secs: intervalSecs,
     last_exit_code: state?.last_exit_code,
     last_error: state?.last_error,
     last_finished_at: state?.last_finished_at,
@@ -733,6 +774,25 @@ function getDistillationWorkerStatus(
   };
 }
 
+function stopLegacyDistillationWorker(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): void {
+  const statePath = distillationWorkerStatePath(config, projectRoot);
+  const state = readJsonFile<{ pid?: number; runtime?: string }>(statePath);
+  if (!state || state.runtime === "openclaw_plugin_service") {
+    return;
+  }
+  const pid = state.pid;
+  if (pid && isPidAlive(pid)) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      // Ignore pid races; service mode will overwrite state below.
+    }
+  }
+}
+
 function summarizeDistillationWorkerError(error: string): string {
   const trimmed = error.trim();
   if (!trimmed) {
@@ -790,8 +850,14 @@ function buildDistillationWorkerHealth(
 
   return {
     status: "stopped",
-    summary: "The plugin-managed host-model distillation worker is not currently running.",
-    action: "Run openclaw repair_opensyn to restart the worker.",
+    summary:
+      status.source === "openclaw_host_model_service"
+        ? "The plugin-managed host-model distillation service is not currently reporting healthy heartbeats."
+        : "The plugin-managed host-model distillation worker is not currently running.",
+    action:
+      status.source === "openclaw_host_model_service"
+        ? "Restart the OpenClaw gateway if needed, then run openclaw repair_opensyn to refresh OpenSyn state."
+        : "Run openclaw repair_opensyn to restart the worker.",
     log_path: status.log_path,
     last_finished_at: status.last_finished_at,
   };
@@ -906,6 +972,7 @@ function buildUserNextStep(params: {
       status: "required",
       code: "repair_distillation_worker",
       summary:
+        distillationWorkerHealth.summary ||
         "The plugin-managed host-model distillation worker is not healthy, so OpenSyn cannot keep refining new activity automatically.",
       action:
         distillationWorkerHealth.action ||
@@ -930,63 +997,350 @@ function buildUserNextStep(params: {
   };
 }
 
-async function ensureDistillationWorker(
+function buildHostDistillationPrompt(projectRoot: string): string {
+  return [
+    `Run exactly one OpenSyn autonomous distillation cycle for project ${projectRoot}.`,
+    "Rules:",
+    "- Use only the OpenClaw-configured host model already available to this local runtime.",
+    "- Do not browse, do not call external network tools, and do not use any model outside OpenClaw.",
+    "- First call opensyn_autonomous_tick with no arguments.",
+    "- If automation_state is idle_waiting_for_activity, stop immediately.",
+    "- If automation_state is distillation_work_ready, follow cycle_plan.primary_steps in order.",
+    "- If the primary path cannot complete safely, follow cycle_plan.fallback_steps.",
+    "- Always execute cycle_plan.resume_steps before ending when they are available.",
+    "- Complete at most one queued work packet in this run.",
+    "- End with one short sentence describing the outcome.",
+  ].join("\n");
+}
+
+function resolveOpenClawCommand(
   config: ResolvedOpenSynConfig,
-  projectRoot: string,
-): Promise<DistillationWorkerStatus> {
-  const status = getDistillationWorkerStatus(config, projectRoot);
-  if (!status.enabled || status.running) {
-    return status;
+  args: string[],
+): { command: string; commandArgs: string[] } {
+  const openclawBin = config.openclawBin;
+  if (openclawBin.endsWith(".mjs") || openclawBin.endsWith(".js")) {
+    return {
+      command: stableNodeRunner(),
+      commandArgs: [openclawBin, ...args],
+    };
   }
+  return {
+    command: openclawBin,
+    commandArgs: args,
+  };
+}
 
-  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);
+async function runSpawnedCommand(params: {
+  command: string;
+  args: string[];
+  cwd?: string;
+  timeoutMs: number;
+  onSpawn?: (pid?: number) => void;
+}): Promise<SpawnResponse> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(params.command, params.args, {
+      cwd: params.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
 
-  writeFileSync(
-    statePath,
-    `${JSON.stringify(
-      {
-        pid: child.pid,
-        source: "openclaw_host_model_agent",
+    params.onSpawn?.(child.pid);
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill("SIGTERM");
+      reject(new Error(`${path.basename(params.command)} timed out after ${params.timeoutMs}ms`));
+    }, params.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(() =>
+        resolve({
+          stdout,
+          stderr,
+          exitCode: code,
+        }),
+      );
+    });
+  });
+}
+
+function deriveDistillationProjectRoot(
+  config: ResolvedOpenSynConfig,
+  ctx: OpenClawPluginServiceContext,
+): string | null {
+  const projectRoot = config.defaultProjectRoot || ctx.workspaceDir;
+  return projectRoot ? path.resolve(projectRoot) : null;
+}
+
+function createOpenSynDistillationService(api: OpenClawPluginApi) {
+  let timer: NodeJS.Timeout | null = null;
+  let currentChildPid: number | undefined;
+  let runningCycle = false;
+  let lastCycleStartedAt = 0;
+  let lifecycleRevision = 0;
+
+  async function runCycle(
+    ctx: OpenClawPluginServiceContext,
+    config: ResolvedOpenSynConfig,
+    projectRoot: string,
+  ): Promise<void> {
+    if (runningCycle) {
+      return;
+    }
+
+    runningCycle = true;
+    const statePath = distillationWorkerStatePath(config, projectRoot);
+    const logPath = distillationWorkerLogPath(config, projectRoot);
+    const startedAt = new Date().toISOString();
+
+    try {
+      stopLegacyDistillationWorker(config, projectRoot);
+      updateJsonStateFile(statePath, {
+        runtime: "openclaw_plugin_service",
+        manager_pid: process.pid,
         project_root: projectRoot,
+        source: "openclaw_host_model_service",
         openclaw_bin: config.openclawBin,
         agent_id: config.distillationWorkerAgentId,
         interval_secs: config.distillationWorkerIntervalSecs,
-        started_at: new Date().toISOString(),
+        state_path: statePath,
         log_path: logPath,
-        last_exit_code: null,
-        last_error: "",
-      },
-      null,
-      2,
-    )}\n`,
-    "utf8",
-  );
+        service_started_at: startedAt,
+        service_heartbeat_at: startedAt,
+        running: true,
+      });
+
+      if (!config.distillationWorkerEnabled) {
+        updateJsonStateFile(statePath, {
+          service_heartbeat_at: new Date().toISOString(),
+          last_error: "",
+        });
+        return;
+      }
+
+      const prompt = buildHostDistillationPrompt(projectRoot);
+      const { command, commandArgs } = resolveOpenClawCommand(config, [
+        "agent",
+        "--local",
+        "--agent",
+        config.distillationWorkerAgentId,
+        "--thinking",
+        "minimal",
+        "--timeout",
+        "120",
+        "--message",
+        prompt,
+        "--json",
+      ]);
+
+      const result = await runSpawnedCommand({
+        command,
+        args: commandArgs,
+        cwd: projectRoot,
+        timeoutMs: Math.max(config.daemonTimeoutMs, 120_000),
+        onSpawn(pid) {
+          currentChildPid = pid;
+          updateJsonStateFile(statePath, {
+            current_child_pid: pid,
+            last_started_at: startedAt,
+            service_heartbeat_at: startedAt,
+          });
+        },
+      });
+
+      const finishedAt = new Date().toISOString();
+      const computedLastError =
+        result.exitCode && result.exitCode !== 0
+          ? result.stderr.trim() || `openclaw agent exited with ${result.exitCode}`
+          : "";
+      const payload = {
+        runtime: "openclaw_plugin_service",
+        manager_pid: process.pid,
+        source: "openclaw_host_model_service",
+        current_child_pid: null,
+        last_started_at: startedAt,
+        last_finished_at: finishedAt,
+        last_exit_code: result.exitCode,
+        last_error: computedLastError,
+        last_stdout: result.stdout.trim(),
+        last_stderr: result.stderr.trim(),
+        service_heartbeat_at: finishedAt,
+      };
+      updateJsonStateFile(statePath, payload);
+      appendLogLine(
+        logPath,
+        JSON.stringify({
+          started_at: startedAt,
+          finished_at: finishedAt,
+          command,
+          command_args: commandArgs,
+          exit_code: result.exitCode,
+          error: computedLastError,
+          stdout: result.stdout.trim(),
+          stderr: result.stderr.trim(),
+        }),
+      );
+      ctx.logger.info(
+        computedLastError
+          ? `opensyn distillation cycle finished with error: ${summarizeDistillationWorkerError(computedLastError)}`
+          : "opensyn distillation cycle completed",
+      );
+    } catch (error) {
+      const finishedAt = new Date().toISOString();
+      const message = error instanceof Error ? error.message : String(error);
+      updateJsonStateFile(statePath, {
+        runtime: "openclaw_plugin_service",
+        manager_pid: process.pid,
+        source: "openclaw_host_model_service",
+        current_child_pid: null,
+        last_started_at: startedAt,
+        last_finished_at: finishedAt,
+        last_error: message,
+        service_heartbeat_at: finishedAt,
+      });
+      appendLogLine(
+        logPath,
+        JSON.stringify({
+          started_at: startedAt,
+          finished_at: finishedAt,
+          error: message,
+        }),
+      );
+      ctx.logger.warn(`opensyn distillation cycle failed: ${message}`);
+    } finally {
+      currentChildPid = undefined;
+      runningCycle = false;
+    }
+  }
+
+  async function tick(ctx: OpenClawPluginServiceContext): Promise<void> {
+    const config = getResolvedPluginConfig(api, {
+      defaultProjectRoot: ctx.workspaceDir,
+    });
+    const projectRoot = deriveDistillationProjectRoot(config, ctx);
+    if (!projectRoot) {
+      return;
+    }
+
+    const intervalMs = Math.max(5, config.distillationWorkerIntervalSecs) * 1000;
+    if (Date.now() - lastCycleStartedAt < intervalMs) {
+      const statePath = distillationWorkerStatePath(config, projectRoot);
+      updateJsonStateFile(statePath, {
+        runtime: "openclaw_plugin_service",
+        manager_pid: process.pid,
+        source: "openclaw_host_model_service",
+        project_root: projectRoot,
+        interval_secs: config.distillationWorkerIntervalSecs,
+        service_heartbeat_at: new Date().toISOString(),
+      });
+      return;
+    }
+
+    lastCycleStartedAt = Date.now();
+    await runCycle(ctx, config, projectRoot);
+  }
+
+  return {
+    id: "opensyn-distillation-service",
+    async start(ctx: OpenClawPluginServiceContext): Promise<void> {
+      lifecycleRevision += 1;
+      const currentRevision = lifecycleRevision;
+      const config = getResolvedPluginConfig(api, {
+        defaultProjectRoot: ctx.workspaceDir,
+      });
+      const projectRoot = deriveDistillationProjectRoot(config, ctx);
+      if (projectRoot) {
+        stopLegacyDistillationWorker(config, projectRoot);
+        updateJsonStateFile(distillationWorkerStatePath(config, projectRoot), {
+          runtime: "openclaw_plugin_service",
+          manager_pid: process.pid,
+          source: "openclaw_host_model_service",
+          project_root: projectRoot,
+          openclaw_bin: config.openclawBin,
+          agent_id: config.distillationWorkerAgentId,
+          interval_secs: config.distillationWorkerIntervalSecs,
+          state_path: distillationWorkerStatePath(config, projectRoot),
+          log_path: distillationWorkerLogPath(config, projectRoot),
+          service_started_at: new Date().toISOString(),
+          service_heartbeat_at: new Date().toISOString(),
+          running: true,
+          last_error: "",
+        });
+      }
+
+      void tick(ctx);
+      timer = setInterval(() => {
+        if (currentRevision !== lifecycleRevision) {
+          return;
+        }
+        void tick(ctx);
+      }, 5_000);
+      timer.unref?.();
+      ctx.logger.info("opensyn distillation service started");
+    },
+    async stop(ctx: OpenClawPluginServiceContext): Promise<void> {
+      lifecycleRevision += 1;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (currentChildPid && isPidAlive(currentChildPid)) {
+        try {
+          process.kill(currentChildPid, "SIGTERM");
+        } catch {
+          // Ignore pid races during shutdown.
+        }
+      }
+      const config = getResolvedPluginConfig(api, {
+        defaultProjectRoot: ctx.workspaceDir,
+      });
+      const projectRoot = deriveDistillationProjectRoot(config, ctx);
+      if (projectRoot) {
+        updateJsonStateFile(distillationWorkerStatePath(config, projectRoot), {
+          runtime: "openclaw_plugin_service",
+          manager_pid: process.pid,
+          source: "openclaw_host_model_service",
+          current_child_pid: null,
+          service_stopped_at: new Date().toISOString(),
+          service_heartbeat_at: new Date().toISOString(),
+          running: false,
+        });
+      }
+      currentChildPid = undefined;
+      runningCycle = false;
+      ctx.logger.info("opensyn distillation service stopped");
+    },
+  };
+}
+
+async function ensureDistillationWorker(
+  config: ResolvedOpenSynConfig,
+  projectRoot: string,
+): Promise<DistillationWorkerStatus> {
+  stopLegacyDistillationWorker(config, projectRoot);
   return getDistillationWorkerStatus(config, projectRoot);
 }
 
@@ -995,14 +1349,23 @@ function stopDistillationWorker(
   projectRoot: string,
 ): DistillationWorkerStatus {
   const status = getDistillationWorkerStatus(config, projectRoot);
-  if (status.running && status.pid) {
+  if (status.source === "openclaw_host_model_agent" && 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 });
+  updateJsonStateFile(status.state_path, {
+    runtime:
+      status.source === "openclaw_host_model_service"
+        ? "openclaw_plugin_service"
+        : "legacy",
+    running: false,
+    current_child_pid: null,
+    last_error: "",
+    service_heartbeat_at: new Date().toISOString(),
+  });
   return getDistillationWorkerStatus(config, projectRoot);
 }
 
@@ -1301,6 +1664,22 @@ function summarizeResult(result: unknown): string {
     return summarizeContextObject(result as ContextLike);
   }
 
+  if (looksLikeCollectionReport(result)) {
+    return summarizeCollectionReport(
+      result as {
+        project_root?: string;
+        audit_stats?: AuditStatsLike;
+        current_context?: ContextLike | null;
+        recent_episodes?: ContextLike[];
+        approved_assets?: AssetLike[];
+        candidate_assets?: AssetLike[];
+        pending_jobs?: DistillationJobLike[];
+        runtime_overlay?: RuntimeOverlayLike | null;
+        next_step?: UserNextStep;
+      },
+    );
+  }
+
   if (looksLikeAutonomousCollectionBootstrap(result)) {
     return summarizeAutonomousCollectionBootstrap(
       result as {
@@ -1372,6 +1751,10 @@ function summarizeResult(result: unknown): string {
     return summarizeRuntimeOverlay(result as RuntimeOverlayLike);
   }
 
+  if (looksLikeAuditStats(result)) {
+    return summarizeAuditStats(result as AuditStatsLike);
+  }
+
   if (looksLikeAssetDiff(result)) {
     return summarizeAssetDiff(result as AssetDiffLike);
   }
@@ -1593,6 +1976,35 @@ function summarizeAssetApprovalResult(result: {
   return `${base} | synced_records=${String(sync.applied_record_count ?? 0)} | host=${sync.host || "unknown"}`;
 }
 
+function summarizeAuditStats(result: AuditStatsLike): string {
+  return `OpenSyn collected data | raw_events=${String(result.raw_event_count ?? 0)} | episodes=${String(result.task_episode_count ?? 0)} | context_packs=${String(result.context_pack_count ?? 0)} | assets=${String(result.agent_asset_count ?? 0)} | projects=${String(result.projects?.length ?? 0)}`;
+}
+
+function summarizeCollectionReport(result: {
+  project_root?: string;
+  audit_stats?: AuditStatsLike;
+  current_context?: ContextLike | null;
+  recent_episodes?: ContextLike[];
+  approved_assets?: AssetLike[];
+  candidate_assets?: AssetLike[];
+  pending_jobs?: DistillationJobLike[];
+  runtime_overlay?: RuntimeOverlayLike | null;
+  next_step?: UserNextStep;
+}): string {
+  const rawEvents = result.audit_stats?.raw_event_count ?? 0;
+  const episodes = result.audit_stats?.task_episode_count ?? result.recent_episodes?.length ?? 0;
+  const assets = result.audit_stats?.agent_asset_count ?? 0;
+  const approved = result.runtime_overlay?.approved_asset_count ?? result.approved_assets?.length ?? 0;
+  const pendingJobs = result.pending_jobs?.length ?? result.runtime_overlay?.pending_distillation_jobs ?? 0;
+  const leadContext =
+    result.current_context?.title ||
+    result.current_context?.summary ||
+    result.current_context?.semantic_hint?.activity_kind ||
+    "none";
+  const nextStep = result.next_step?.code || "none";
+  return `OpenSyn report | project=${result.project_root || "unknown"} | raw_events=${String(rawEvents)} | episodes=${String(episodes)} | assets=${String(assets)} | approved_assets=${String(approved)} | pending_jobs=${String(pendingJobs)} | current=${leadContext} | next=${nextStep}`;
+}
+
 function extractNextStep(result: unknown): UserNextStep | undefined {
   if (typeof result !== "object" || result === null) {
     return undefined;
@@ -1732,6 +2144,24 @@ function looksLikeRuntimeOverlay(result: unknown): boolean {
   );
 }
 
+function looksLikeAuditStats(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    ("raw_event_count" in result || "context_pack_count" in result || "task_episode_count" in result)
+  );
+}
+
+function looksLikeCollectionReport(result: unknown): boolean {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "audit_stats" in result &&
+    "current_context" in result &&
+    "runtime_overlay" in result
+  );
+}
+
 function looksLikeAutonomousCollectionBootstrap(result: unknown): boolean {
   return (
     typeof result === "object" &&
@@ -2105,6 +2535,74 @@ async function repairAutonomousCollection(
   };
 }
 
+async function getOpenSynCollectionReport(
+  config: ResolvedOpenSynConfig,
+  params: { project_root: string; shell?: string },
+) {
+  const status = await getAutonomousCollectionStatus(config, params);
+  const auditStats = await callDaemon(config, "list_collected_event_stats", {});
+  const currentContext = await callDaemon(config, "synthesize_recent_activity", {
+    project_root: params.project_root,
+    window_secs: config.defaultWindowSecs ?? 300,
+    limit: 512,
+  });
+  const recentEpisodes = await callDaemon(config, "get_recent_task_episodes", {
+    project_root: params.project_root,
+    limit: 5,
+  });
+  const approvedAssets = await callDaemon(config, "list_agent_assets", {
+    project_root: params.project_root,
+    status: "approved",
+    limit: 5,
+  });
+  const candidateAssets = await callDaemon(config, "list_agent_assets", {
+    project_root: params.project_root,
+    status: "candidate",
+    limit: 5,
+  });
+  const pendingJobs = await callDaemon(config, "list_distillation_jobs", {
+    project_root: params.project_root,
+    status: "pending",
+    limit: 5,
+  });
+  const runtimeOverlay = await callDaemon(config, "get_agent_runtime_overlay", {
+    project_root: params.project_root,
+    host: config.projectionHost || "openclaw",
+  });
+
+  return {
+    semantic_hint: {
+      activity_kind: "collection_report",
+      status_label: "inspected",
+      operator_focus:
+        "Review what OpenSyn has collected, the latest current context, asset distillation results, and pending host-model work.",
+    },
+    project_root: params.project_root,
+    status,
+    audit_stats: auditStats,
+    current_context: currentContext,
+    recent_episodes: recentEpisodes,
+    approved_assets: approvedAssets,
+    candidate_assets: candidateAssets,
+    pending_jobs: pendingJobs,
+    runtime_overlay: runtimeOverlay,
+    next_step:
+      extractNextStep(status) ||
+      buildUserNextStep({
+        collectionMode:
+          (status as { collection_settings?: CollectionSettingsLike })?.collection_settings
+            ?.mode,
+        backgroundWatch:
+          (status as { background_watch?: BackgroundWatchStatus }).background_watch,
+        shellCaptureHealth:
+          (status as { shell_capture_health?: ShellCaptureHealth }).shell_capture_health,
+        distillationWorkerHealth:
+          (status as { distillation_worker_health?: DistillationWorkerHealth })
+            .distillation_worker_health,
+      }),
+  };
+}
+
 function printCliResult(result: unknown, jsonOutput = false): void {
   const summary = summarizeResult(result);
   if (summary) {
@@ -2130,6 +2628,8 @@ export default {
   register(api: OpenClawPluginApi) {
     const config = getResolvedPluginConfig(api);
 
+    api.registerService(createOpenSynDistillationService(api));
+
     api.registerCli(
       ({ program, workspaceDir }) => {
         const resolveCliProjectRoot = (input?: string): string =>
@@ -2155,6 +2655,99 @@ export default {
           return persisted;
         };
 
+        program
+          .command("report_opensyn")
+          .description(
+            "Show an OpenSyn collection report for the current workspace, including captured data counts, current context, asset previews, and pending distillation jobs.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--shell <shell>", "Shell to inspect for command capture.")
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string; json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getOpenSynCollectionReport(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result, opts?.json);
+          });
+
+        program
+          .command("context_opensyn")
+          .description(
+            "Show the latest synthesized OpenSyn context for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await callDaemon(resolved, "synthesize_recent_activity", {
+              project_root: projectRoot,
+              window_secs: resolved.defaultWindowSecs ?? 300,
+              limit: 512,
+            });
+            printCliResult(result, opts?.json);
+          });
+
+        program
+          .command("assets_opensyn")
+          .description(
+            "List recent OpenSyn agent assets for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--status <status>", "Optional asset status filter.")
+          .option("--kind <kind>", "Optional asset kind filter.")
+          .option("--limit <limit>", "Maximum assets to show.", (value) => Number.parseInt(value, 10))
+          .option("--json", "Print the full JSON result.")
+          .action(
+            async (
+              projectRootArg?: string,
+              opts?: { status?: string; kind?: string; limit?: number; json?: boolean },
+            ) => {
+              const projectRoot = resolveCliProjectRoot(projectRootArg);
+              const resolved = await resolveCliConfig(projectRoot);
+              const result = await callDaemon(resolved, "list_agent_assets", {
+                project_root: projectRoot,
+                status: opts?.status,
+                kind: opts?.kind,
+                limit: opts?.limit ?? resolved.defaultSearchLimit ?? 10,
+              });
+              printCliResult(result, opts?.json);
+            },
+          );
+
+        program
+          .command("stats_opensyn")
+          .description(
+            "Show collected OpenSyn data counts for the current workspace.",
+          )
+          .option("--json", "Print the full JSON result.")
+          .action(async (opts?: { json?: boolean }) => {
+            const resolved = await resolveCliConfig(resolveCliProjectRoot());
+            const result = await callDaemon(resolved, "list_collected_event_stats", {});
+            printCliResult(result, opts?.json);
+          });
+
+        program
+          .command("episodes_opensyn")
+          .description(
+            "List recent OpenSyn task episodes for the current workspace.",
+          )
+          .argument("[project_root]", "Optional project root. Defaults to the current OpenClaw workspace.")
+          .option("--limit <limit>", "Maximum episodes to show.", (value) => Number.parseInt(value, 10))
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { limit?: number; json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await callDaemon(resolved, "get_recent_task_episodes", {
+              project_root: projectRoot,
+              limit: opts?.limit ?? resolved.defaultSearchLimit ?? 10,
+            });
+            printCliResult(result, opts?.json);
+          });
+
         program
           .command("enable_opensyn")
           .description(
@@ -2272,6 +2865,89 @@ export default {
           .command("opensyn")
           .description("OpenSyn management commands.");
 
+        opensyn
+          .command("report")
+          .description("Alias for openclaw report_opensyn.")
+          .argument("[project_root]")
+          .option("--shell <shell>")
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { shell?: string; json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await getOpenSynCollectionReport(resolved, {
+              project_root: projectRoot,
+              shell: opts?.shell,
+            });
+            printCliResult(result, opts?.json);
+          });
+
+        opensyn
+          .command("context")
+          .description("Alias for openclaw context_opensyn.")
+          .argument("[project_root]")
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await callDaemon(resolved, "synthesize_recent_activity", {
+              project_root: projectRoot,
+              window_secs: resolved.defaultWindowSecs ?? 300,
+              limit: 512,
+            });
+            printCliResult(result, opts?.json);
+          });
+
+        opensyn
+          .command("assets")
+          .description("Alias for openclaw assets_opensyn.")
+          .argument("[project_root]")
+          .option("--status <status>")
+          .option("--kind <kind>")
+          .option("--limit <limit>", "Maximum assets to show.", (value) => Number.parseInt(value, 10))
+          .option("--json", "Print the full JSON result.")
+          .action(
+            async (
+              projectRootArg?: string,
+              opts?: { status?: string; kind?: string; limit?: number; json?: boolean },
+            ) => {
+              const projectRoot = resolveCliProjectRoot(projectRootArg);
+              const resolved = await resolveCliConfig(projectRoot);
+              const result = await callDaemon(resolved, "list_agent_assets", {
+                project_root: projectRoot,
+                status: opts?.status,
+                kind: opts?.kind,
+                limit: opts?.limit ?? resolved.defaultSearchLimit ?? 10,
+              });
+              printCliResult(result, opts?.json);
+            },
+          );
+
+        opensyn
+          .command("stats")
+          .description("Alias for openclaw stats_opensyn.")
+          .option("--json", "Print the full JSON result.")
+          .action(async (opts?: { json?: boolean }) => {
+            const resolved = await resolveCliConfig(resolveCliProjectRoot());
+            const result = await callDaemon(resolved, "list_collected_event_stats", {});
+            printCliResult(result, opts?.json);
+          });
+
+        opensyn
+          .command("episodes")
+          .description("Alias for openclaw episodes_opensyn.")
+          .argument("[project_root]")
+          .option("--limit <limit>", "Maximum episodes to show.", (value) => Number.parseInt(value, 10))
+          .option("--json", "Print the full JSON result.")
+          .action(async (projectRootArg?: string, opts?: { limit?: number; json?: boolean }) => {
+            const projectRoot = resolveCliProjectRoot(projectRootArg);
+            const resolved = await resolveCliConfig(projectRoot);
+            const result = await callDaemon(resolved, "get_recent_task_episodes", {
+              project_root: projectRoot,
+              limit: opts?.limit ?? resolved.defaultSearchLimit ?? 10,
+            });
+            printCliResult(result, opts?.json);
+          });
+
         opensyn
           .command("enable")
           .description("Alias for openclaw enable_opensyn.")
@@ -2356,6 +3032,11 @@ export default {
       },
       {
         commands: [
+          "report_opensyn",
+          "context_opensyn",
+          "assets_opensyn",
+          "stats_opensyn",
+          "episodes_opensyn",
           "enable_opensyn",
           "disable_opensyn",
           "status_opensyn",
@@ -2367,6 +3048,54 @@ export default {
       },
     );
 
+    api.registerTool(
+      {
+        name: "opensyn_collection_report",
+        description:
+          "Return an aggregated OpenSyn report for the current project: collection health, captured data counts, current context, recent episodes, asset previews, runtime overlay, and pending distillation jobs.",
+        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 getOpenSynCollectionReport(config, {
+            project_root: projectRoot,
+            shell: params.shell,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
+    api.registerTool(
+      {
+        name: "opensyn_collected_stats",
+        description:
+          "Return raw OpenSyn collection counts such as raw events, task episodes, context packs, and stored assets.",
+        parameters: Type.Object({}),
+        async execute() {
+          const result = await callDaemon(config, "list_collected_event_stats", {});
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
     api.registerTool(
       {
         name: "opensyn_recent_failure",
@@ -2489,6 +3218,35 @@ export default {
       { optional: true },
     );
 
+    api.registerTool(
+      {
+        name: "opensyn_recent_episodes",
+        description:
+          "Return recent OpenSyn task episodes for the current project so the host can inspect what was just collected.",
+        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, "get_recent_task_episodes", {
+            project_root: projectRoot,
+            limit: params.limit ?? config.defaultSearchLimit ?? 10,
+          });
+          return asText(result);
+        },
+      },
+      { optional: true },
+    );
+
     api.registerTool(
       {
         name: "opensyn_distill_assets",