@scrylog/cli 0.1.0

package/src/legacy/classifier.ts

@@ -0,0 +1,215 @@
+import { detectTool, getPreviewMatchPositions, previewSignals } from "./detect";
+import type {
+  DetectionReason,
+  EnrichedPaneRecord,
+  PaneModel,
+  PaneSample,
+  PaneState,
+  ProcessInfo,
+  SnapshotHistory,
+  ToolKind,
+} from "../shared/types";
+import { cleanSummaryText, compactWhitespace, normalizeCommandName, pickCompletionTail, pickMeaningfulTail, pickQuestionTail, pickSummaryTail } from "../shared/utils";
+
+const DEBOUNCE_THRESHOLD = 2;
+
+export function classifyPane(input: {
+  pane: EnrichedPaneRecord;
+  processTree: ProcessInfo[];
+  sample: PaneSample | null;
+  history?: SnapshotHistory;
+  now: number;
+}): { pane: PaneModel; history: SnapshotHistory } {
+  const { pane, processTree, sample, history, now } = input;
+  const detectedTool = detectTool(pane.currentCommand, processTree);
+  const rawState = detectState(detectedTool.tool, pane.currentCommand, processTree, sample);
+
+  const fingerprint = [
+    detectedTool.tool,
+    rawState.state,
+    processTree.map((process) => `${process.pid}:${process.comm}`).join(","),
+    sample?.preview ?? "",
+  ].join("|");
+
+  const lastChangedAt = history?.lastChangedAt ?? now;
+  const stableCount = history?.lastFingerprint === fingerprint ? (history.stableCount + 1) : 1;
+
+  let tool: ToolKind = detectedTool.tool;
+  let state: PaneState = rawState.state;
+  let stateReasons = rawState.reasons;
+  const shouldBypassDebounce = rawState.state === "working"
+    && rawState.reasons.some((reason) => (
+      reason.label === "activity keywords"
+      || reason.label === "opencode footer activity"
+      || reason.label === "active agent signals"
+    ));
+
+  if (history && stableCount < DEBOUNCE_THRESHOLD && !shouldBypassDebounce) {
+    tool = history.tool;
+    state = history.state;
+    stateReasons = [
+      {
+        label: "debounced previous state",
+        detail: `holding ${history.state} until new signal stabilizes`,
+      },
+      ...rawState.reasons,
+    ];
+  }
+
+  const historyRecord: SnapshotHistory = {
+    tool,
+    state,
+    lastFingerprint: fingerprint,
+    lastChangedAt: ((stableCount === DEBOUNCE_THRESHOLD && history?.state !== state) || (shouldBypassDebounce && stableCount === 1)) ? now : lastChangedAt,
+    stableCount,
+  };
+
+  const processChain = processTree.map((process) => compactWhitespace(process.comm || normalizeCommandName(process.command)));
+  const summary = summarizeState(state, stateReasons, sample, processChain, pane.currentCommand);
+
+  return {
+    pane: {
+      ...pane,
+      processTree,
+      processChain,
+      sample,
+      tool,
+      state,
+      toolReasons: detectedTool.reasons,
+      stateReasons,
+      summary,
+      lastChangedAt: historyRecord.lastChangedAt,
+      stableForMs: Math.max(0, now - historyRecord.lastChangedAt),
+      hasAttention: state === "waiting-input",
+    },
+    history: historyRecord,
+  };
+}
+
+export function detectState(tool: ToolKind, currentCommand: string, processTree: ProcessInfo[], sample: PaneSample | null): { state: PaneState; reasons: DetectionReason[] } {
+  const reasons: DetectionReason[] = [];
+  const promptSignals = previewSignals(sample);
+  const previewMatches = getPreviewMatchPositions(sample);
+  const processStates = processTree.map((process) => process.state).join(",");
+  const commands = [currentCommand, ...processTree.map((process) => process.command)].join(" ");
+  const meaningfulPreview = sample ? pickMeaningfulTail(sample.lines, sample.preview) : "";
+
+  if (tool === "shell") {
+    reasons.push({ label: "shell pane", detail: compactWhitespace(currentCommand || processTree[0]?.command || "shell") });
+    return { state: "shell", reasons };
+  }
+
+  if (tool === "unknown") {
+    reasons.push({ label: "insufficient classification signals", detail: compactWhitespace(commands) || "unknown workload" });
+    return { state: "unknown", reasons };
+  }
+
+  const activityReason = promptSignals.find((reason) => reason.label === "activity keywords");
+  const footerReason = promptSignals.find((reason) => reason.label === "opencode footer activity");
+  const waitingReason = promptSignals.find((reason) => {
+    if (reason.label !== "input prompt keywords" && reason.label !== "prompt-like tail") {
+      return false;
+    }
+
+    return !/^>\s*implement\s*\{feature\}/i.test(reason.detail);
+  });
+  const completionReason = promptSignals.find((reason) => reason.label === "completion keywords");
+  const activeKeywords = /(thinking|generating|executing|applying|running|streaming|analyzing|diff|patch|searching|reading)/i;
+  const strongWorkingSignal = Boolean(
+    (activityReason && /(working\s*\(|background terminal running|waited for background terminal|created\s+\d+)/i.test(activityReason.detail))
+      || (tool === "opencode" && footerReason),
+  );
+  const hasRunnableProcessSignal = processTree.some((process) => /[RU]/.test(process.state));
+  const hasActiveProcessSignal = hasRunnableProcessSignal;
+  const hasFreshActivitySignal = Boolean(
+    previewMatches.activityIndex >= Math.max(previewMatches.promptIndex, previewMatches.completionIndex)
+      && (
+        (activityReason && (cleanSummaryText(activityReason.detail) === meaningfulPreview || activeKeywords.test(meaningfulPreview)))
+        || (tool === "opencode" && footerReason)
+      ),
+  );
+
+  if (completionReason && !hasActiveProcessSignal && previewMatches.completionIndex >= previewMatches.activityIndex) {
+    reasons.push({
+      label: "completed work detected",
+      detail: completionReason.detail,
+    });
+    // For Codex, generic prompt patterns (e.g. ›) are normal UI — not a
+    // question from the agent. Only detectCodexPermissionPrompt can determine
+    // waiting-input for Codex.
+    const isCodexWaiting = tool === "codex" ? false : Boolean(waitingReason);
+    return { state: isCodexWaiting ? "waiting-input" : "idle", reasons: isCodexWaiting ? [...reasons, waitingReason!] : reasons };
+  }
+
+  if (strongWorkingSignal || hasFreshActivitySignal) {
+    if (footerReason && tool === "opencode") {
+      reasons.push(footerReason);
+    } else if (activityReason) {
+      reasons.push(activityReason);
+    }
+    return { state: "working", reasons };
+  }
+
+  if (waitingReason) {
+    if (tool === "codex") {
+      // Codex › prompt is normal UI, not a question from the agent.
+      // Only detectCodexPermissionPrompt can determine waiting-input for codex.
+      return { state: "idle", reasons: [...reasons, waitingReason, { label: "codex prompt is normal ui", detail: "› is not a question" }] };
+    }
+    reasons.push(waitingReason);
+    return { state: "waiting-input", reasons };
+  }
+
+  if (hasActiveProcessSignal) {
+    reasons.push(footerReason ?? activityReason ?? { label: "active agent signals", detail: meaningfulPreview || processStates || compactWhitespace(commands) });
+    return { state: "working", reasons };
+  }
+
+  reasons.push({ label: "agent present without active signals", detail: meaningfulPreview || compactWhitespace(commands) || tool });
+  return { state: "idle", reasons };
+}
+
+function summarizeState(
+  state: PaneState,
+  stateReasons: DetectionReason[],
+  sample: PaneSample | null,
+  processChain: string[],
+  currentCommand: string,
+): string {
+  const primaryReason = stateReasons.find((reason) => reason.label !== "debounced previous state")?.detail;
+  const hasCompletionReason = stateReasons.some((reason) => reason.label === "completed work detected" || reason.label === "completion keywords");
+  const preferredSummary = state === "waiting-input"
+    ? pickQuestionTail(sample?.lines ?? [], primaryReason ?? "")
+    : hasCompletionReason
+      ? pickCompletionTail(sample?.lines ?? [], primaryReason ?? "")
+      : pickSummaryTail(sample?.lines ?? [], primaryReason ?? "");
+
+  if (primaryReason && primaryReason.length > 0 && primaryReason === preferredSummary) {
+    return primaryReason;
+  }
+
+  if (sample?.lines.length) {
+    const meaningful = state === "waiting-input"
+      ? pickQuestionTail(sample.lines, sample.preview)
+      : hasCompletionReason
+        ? pickCompletionTail(sample.lines, sample.preview)
+      : pickSummaryTail(sample.lines, sample.preview);
+    if (meaningful) {
+      return meaningful;
+    }
+  }
+
+  if (sample?.preview) {
+    return sample.preview;
+  }
+
+  if (processChain.length > 0) {
+    return processChain.join(" -> ");
+  }
+
+  if (currentCommand) {
+    return currentCommand;
+  }
+
+  return state;
+}

package/src/legacy/detect.ts

@@ -0,0 +1,143 @@
+import type { DetectionReason, PaneSample, ProcessInfo, ToolKind } from "../shared/types";
+import { compactWhitespace, isMostlyUiNoise, isOpencodeFooterLine, isSuggestionStyleText, pickMeaningfulTail, stripAnsiAndUi } from "../shared/utils";
+
+const ACTIVITY_PATTERN = /(thinking|generating|executing|applying|running|streaming|analyzing|^working\s*\(|background terminal running|waited for background terminal|creating|created\s+\d+)/i;
+const PROMPT_PATTERN = /(press enter|continue\?|y\/n|confirm(?:a|as|ar)?\b|waiting for input|type your own answer|send a message|^>\s|^>\b|^\?\s|pregunta clave|^\-\s+¿|^¿)/im;
+const COMPLETION_PATTERN = /(worked for\s+\d|all done|completed|finished|done\b|se cre[oó]\b|cada archivo contiene|ya se escribieron\s+\d+\s+a\s+\d+|contin[uú]o hasta que termine|proceso ya pas[oó]|termin[oó]\s+bien)/i;
+
+const TOOL_PATTERNS: Array<{ tool: ToolKind; regex: RegExp; label: string }> = [
+  { tool: "opencode", regex: /(^|\b)(opencode)(\b|$)/i, label: "process matched opencode" },
+  { tool: "claude", regex: /(?:^|\s|\/)(claude)(?:\s|$)/i, label: "process matched claude" },
+  { tool: "codex", regex: /(^|\b)(codexcli|codex)(\b|$)/i, label: "process matched codex" },
+  { tool: "copilotcli", regex: /(^|\b)(copilotcli|copilot)(\b|$)/i, label: "process matched copilot" },
+];
+
+const SHELL_PATTERN = /(^|\b)(bash|zsh|fish|sh|tmux)(\b|$)/i;
+
+export function detectTool(currentCommand: string, processTree: ProcessInfo[]): { tool: ToolKind; reasons: DetectionReason[] } {
+  const reasons: DetectionReason[] = [];
+  const candidates = [currentCommand, ...processTree.map((process) => `${process.comm} ${process.command}`)];
+
+  for (const candidate of candidates) {
+    for (const pattern of TOOL_PATTERNS) {
+      if (pattern.regex.test(candidate)) {
+        reasons.push({
+          label: pattern.label,
+          detail: compactWhitespace(candidate),
+        });
+        return { tool: pattern.tool, reasons };
+      }
+    }
+  }
+
+  if (candidates.some((candidate) => SHELL_PATTERN.test(candidate))) {
+    reasons.push({
+      label: "shell foreground detected",
+      detail: compactWhitespace(currentCommand || processTree[0]?.command || "shell"),
+    });
+    return { tool: "shell", reasons };
+  }
+
+  reasons.push({
+    label: "no supported tool match",
+    detail: compactWhitespace(candidates.join(" | ")) || "no command context",
+  });
+  return { tool: "unknown", reasons };
+}
+
+export function previewSignals(sample: PaneSample | null): DetectionReason[] {
+  if (!sample || sample.lines.length === 0) {
+    return [];
+  }
+
+  const normalizedLines = sample.lines.map((line) => compactWhitespace(stripAnsiAndUi(line))).filter(Boolean);
+  const recentLines = normalizedLines.slice(-8);
+  const tailWindow = recentLines.filter((line) => !isMostlyUiNoise(line));
+  const preview = pickMeaningfulTail(tailWindow, sample.preview);
+  const reasons: DetectionReason[] = [];
+  const activityMatch = findMatchingLine(tailWindow, ACTIVITY_PATTERN);
+  const promptMatch = findMatchingLine(tailWindow, PROMPT_PATTERN, { excludeSuggestions: true });
+  const completionMatch = findMatchingLine(tailWindow, COMPLETION_PATTERN);
+  const opencodeFooterMatch = findOpencodeFooterSignal(recentLines);
+
+  if (activityMatch) {
+    reasons.push({ label: "activity keywords", detail: activityMatch });
+  }
+
+  if (promptMatch) {
+    reasons.push({ label: "input prompt keywords", detail: promptMatch });
+  }
+
+  if (completionMatch) {
+    reasons.push({ label: "completion keywords", detail: completionMatch });
+  }
+
+  if (opencodeFooterMatch) {
+    reasons.push({ label: "opencode footer activity", detail: opencodeFooterMatch });
+  }
+
+  const lastMeaningful = tailWindow.at(-1) ?? preview;
+  if (!isSuggestionStyleText(lastMeaningful) && (/[:>]\s*$/.test(lastMeaningful) || /^>\s+/.test(lastMeaningful) || /^\?\s+/.test(lastMeaningful))) {
+    reasons.push({ label: "prompt-like tail", detail: lastMeaningful });
+  }
+
+  return reasons;
+}
+
+export function getPreviewMatchPositions(sample: PaneSample | null): { activityIndex: number; promptIndex: number; completionIndex: number } {
+  if (!sample || sample.lines.length === 0) {
+    return { activityIndex: -1, promptIndex: -1, completionIndex: -1 };
+  }
+
+  const normalizedLines = sample.lines.map((line) => compactWhitespace(stripAnsiAndUi(line)));
+  let activityIndex = -1;
+  let promptIndex = -1;
+  let completionIndex = -1;
+
+  for (let index = 0; index < normalizedLines.length; index += 1) {
+    const line = normalizedLines[index] ?? "";
+    if (!line) {
+      continue;
+    }
+    if (ACTIVITY_PATTERN.test(line) || isOpencodeFooterLine(line)) {
+      activityIndex = index;
+    }
+    if (isMostlyUiNoise(line) && !isOpencodeFooterLine(line)) {
+      continue;
+    }
+    if (PROMPT_PATTERN.test(line) && !isSuggestionStyleText(line)) {
+      promptIndex = index;
+    }
+    if (COMPLETION_PATTERN.test(line)) {
+      completionIndex = index;
+    }
+  }
+
+  return { activityIndex, promptIndex, completionIndex };
+}
+
+function findMatchingLine(lines: string[], pattern: RegExp, options?: { excludeSuggestions?: boolean }): string | null {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index] ?? "";
+    if (options?.excludeSuggestions && isSuggestionStyleText(line)) {
+      continue;
+    }
+    if (pattern.test(line)) {
+      return line;
+    }
+  }
+
+  return null;
+}
+
+function findOpencodeFooterSignal(lines: string[]): string | null {
+  const tailLines = lines.slice(-3);
+  for (let index = tailLines.length - 1; index >= 0; index -= 1) {
+    const line = tailLines[index] ?? "";
+    if (isOpencodeFooterLine(line)) {
+      return line;
+    }
+  }
+
+  return null;
+}

package/src/mcp/client-server.ts

@@ -0,0 +1,21 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerAllTools } from "./tools";
+import { registerAllResources } from "./resources";
+import { createApiAdapter } from "./services/api-adapter";
+
+type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+/**
+ * Create an MCP server that fetches data from the daemon API over IPC.
+ * Used by the stdio binary (scrylog-mcp).
+ */
+export function createMcpServerFromApi(daemonFetch: FetchFn): McpServer {
+  const server = new McpServer({
+    name: "scrylog",
+    version: "0.2.0",
+  });
+  const ds = createApiAdapter(daemonFetch);
+  registerAllTools(server, ds);
+  registerAllResources(server, ds);
+  return server;
+}

package/src/mcp/http-handler.ts

@@ -0,0 +1,126 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import type { DaemonStore } from "../daemon/store";
+import type { ScrylogConfig } from "../shared/config";
+import { createMcpServer } from "./server";
+
+function secureCompare(a: string, b: string): boolean {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+
+const CORS_HEADERS_UNSET = {} as Record<string, string>;
+
+function buildCorsHeaders(config: ScrylogConfig): Record<string, string> {
+  if (!config.cors.enabled) return CORS_HEADERS_UNSET;
+  const origins = config.cors.origins.join(", ");
+  const headers: Record<string, string> = {
+    "Access-Control-Allow-Origin": origins,
+    "Access-Control-Allow-Methods": config.cors.methods.join(", "),
+    "Access-Control-Allow-Headers": config.cors.allowedHeaders.join(", "),
+  };
+  if (config.cors.credentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  if (config.cors.maxAge) {
+    headers["Access-Control-Max-Age"] = String(config.cors.maxAge);
+  }
+  if (config.cors.exposedHeaders.length > 0) {
+    headers["Access-Control-Expose-Headers"] = config.cors.exposedHeaders.join(", ");
+  }
+  return headers;
+}
+
+/**
+ * Create the MCP HTTP handler for in-daemon streaming HTTP transport.
+ * Returns null if no MCP port is configured.
+ */
+export function createMcpHttpHandler(
+  store: DaemonStore,
+  config: ScrylogConfig,
+): ((request: Request) => Response | Promise<Response>) | null {
+  if (!config.mcp.httpEnabled || !config.mcp.port) return null;
+
+  const { WebStandardStreamableHTTPServerTransport } = require("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js");
+  const sessions = new Map<string, { transport: InstanceType<typeof WebStandardStreamableHTTPServerTransport>; server: McpServer }>();
+
+  const bearerToken = config.mcp.bearerToken;
+  const corsHeaders = buildCorsHeaders(config);
+
+  return async (request: Request): Promise<Response> => {
+    // CORS preflight
+    if (request.method === "OPTIONS" && config.cors.enabled) {
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+
+    // Bearer token auth
+    if (bearerToken) {
+      const auth = request.headers.get("Authorization");
+      if (!auth || !secureCompare(auth, `Bearer ${bearerToken}`)) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        });
+      }
+    }
+
+    const sessionId = request.headers.get("mcp-session-id") ?? undefined;
+
+    if (sessionId) {
+      const existing = sessions.get(sessionId);
+      if (!existing) {
+        return new Response(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Bad Request: No valid session ID provided" },
+          id: null,
+        }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      return existing.transport.handleRequest(request);
+    }
+
+    let body: unknown;
+    try {
+      body = await request.clone().json();
+    } catch {
+      body = undefined;
+    }
+
+    if (!body || !isInitializeRequest(body)) {
+      return new Response(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Bad Request: No valid session ID provided" },
+        id: null,
+      }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    let transport: InstanceType<typeof WebStandardStreamableHTTPServerTransport> | undefined;
+    const server = createMcpServer(store, config);
+    transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID(),
+      enableJsonResponse: true,
+      onsessioninitialized: (newSessionId: string) => {
+        sessions.set(newSessionId, { transport: transport!, server });
+      },
+      onsessionclosed: (closedSessionId: string) => {
+        const existing = sessions.get(closedSessionId);
+        if (existing) {
+          void existing.server.close();
+          sessions.delete(closedSessionId);
+        }
+      },
+    });
+
+    await server.connect(transport);
+    return transport.handleRequest(request);
+  };
+}

package/src/mcp/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "../shared/config";
+import { createDaemonFetch, getSocketPath } from "../shared/ipc";
+import { IS_WINDOWS } from "../shared/platform";
+import { createMcpServerFromApi } from "./client-server";
+
+function printHelp() {
+  process.stdout.write(`scrylog-mcp
+
+Usage:
+  scrylog-mcp [--config <path>]
+
+Options:
+  --config <path>   Load config from an explicit path
+  -h, --help        Show this help text
+
+Notes:
+  Starts the stdio MCP server and proxies data from scrylogd.
+  The daemon must already be running and reachable.
+`);
+}
+
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+}
+const configFlagIndex = args.indexOf("--config");
+const configPath = configFlagIndex >= 0 ? args[configFlagIndex + 1] : undefined;
+const config = loadConfig(configPath);
+
+if (!config.mcp.stdioEnabled) {
+  process.stderr.write("[scrylog-mcp] MCP stdio is disabled in config.\n");
+  process.exit(1);
+}
+
+const socketPath = IS_WINDOWS ? undefined : getSocketPath(config.daemon.socketPath);
+const daemonFetch = createDaemonFetch({
+  host: config.api.host,
+  port: config.api.port,
+  socketPath,
+  bearerToken: config.api.bearerToken,
+});
+
+// Verify daemon is reachable
+try {
+  const health = await daemonFetch("/api/health");
+  if (!health.ok) {
+    process.stderr.write(`[scrylog-mcp] Daemon returned ${health.status}. Is scrylogd running?\n`);
+    process.exit(1);
+  }
+} catch (error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[scrylog-mcp] Cannot connect to daemon: ${msg}\nIs scrylogd running?\n`);
+  process.exit(1);
+}
+
+const mcp = createMcpServerFromApi(daemonFetch);
+const transport = new StdioServerTransport();
+await mcp.connect(transport);

package/src/mcp/resources/config-current.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+
+export function registerConfigCurrent(server: McpServer, ds: DataSource) {
+  server.resource(
+    "config://current",
+    "Current daemon configuration (redacted)",
+    async () => {
+      const config = await ds.fetchConfig();
+      return {
+        contents: [{
+          uri: "config://current",
+          text: JSON.stringify(config, null, 2),
+          mimeType: "application/json",
+        }],
+      };
+    },
+  );
+}

package/src/mcp/resources/index.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+import { registerSessionsAll } from "./sessions-all";
+import { registerSessionsActive } from "./sessions-active";
+import { registerConfigCurrent } from "./config-current";
+
+export function registerAllResources(server: McpServer, ds: DataSource) {
+  registerSessionsAll(server, ds);
+  registerSessionsActive(server, ds);
+  registerConfigCurrent(server, ds);
+}

package/src/mcp/resources/sessions-active.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+
+export function registerSessionsActive(server: McpServer, ds: DataSource) {
+  server.resource(
+    "sessions://active",
+    "Active sessions (working or waiting-input)",
+    async () => {
+      const sessions = await ds.fetchActiveSessions();
+      return {
+        contents: [{
+          uri: "sessions://active",
+          text: JSON.stringify(sessions, null, 2),
+          mimeType: "application/json",
+        }],
+      };
+    },
+  );
+}

package/src/mcp/resources/sessions-all.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DataSource } from "../services/data-source";
+
+export function registerSessionsAll(server: McpServer, ds: DataSource) {
+  server.resource(
+    "sessions://all",
+    "All monitored sessions as a tree (root sessions with children arrays)",
+    async () => {
+      const sessions = await ds.fetchSessions();
+      return {
+        contents: [{
+          uri: "sessions://all",
+          text: JSON.stringify(sessions, null, 2),
+          mimeType: "application/json",
+        }],
+      };
+    },
+  );
+}

package/src/mcp/schemas/sessions.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+export const SessionIdSchema = z.string().describe("Session ID");

package/src/mcp/server.ts

@@ -0,0 +1,17 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { DaemonStore } from "../daemon/store";
+import type { ScrylogConfig } from "../shared/config";
+import { registerAllTools } from "./tools";
+import { registerAllResources } from "./resources";
+import { createStoreAdapter } from "./services/store-adapter";
+
+export function createMcpServer(store: DaemonStore, config: ScrylogConfig): McpServer {
+  const server = new McpServer({
+    name: "scrylog",
+    version: "0.2.0",
+  });
+  const ds = createStoreAdapter(store, config);
+  registerAllTools(server, ds);
+  registerAllResources(server, ds);
+  return server;
+}