@scrylog/cli 0.1.0

package/src/api/schemas/webhooks/claude.ts

@@ -0,0 +1,32 @@
+import { z } from "@hono/zod-openapi";
+
+// Minimal validation: only 'sessionId' is essential. All other fields are optional
+// and extra fields pass through transparently (.passthrough()) so future changes
+// to the Claude hook format don't cause unexpected rejections.
+export const ClaudeWebhookBodySchema = z
+  .object({
+    sessionId: z.string().openapi({ example: "abc-123-def" }),
+    eventType: z.string().optional().openapi({ example: "PreToolUse" }),
+    eventTime: z.number().optional(),
+    hookSeq: z.number().optional(),
+    state: z.enum(["working", "idle", "waiting-input", "error", "shell", "unknown"]).optional(),
+    hasAttention: z.boolean().optional(),
+    attentionKind: z.enum(["permission", "question", "turn", "none"]).optional(),
+    summary: z.string().optional(),
+    activeTool: z.string().optional(),
+    toolName: z.string().optional(),
+    toolInputSummary: z.string().optional(),
+    toolResultStatus: z.enum(["started", "completed", "error", "blocked", "denied", "unknown"]).optional(),
+    permissionMode: z.string().optional(),
+    startSource: z.string().optional(),
+    endReason: z.string().optional(),
+    errorType: z.string().optional(),
+    agentId: z.string().optional(),
+    agentType: z.string().optional(),
+    transcriptPath: z.string().optional(),
+    currentPath: z.string().optional(),
+    lastActivity: z.number().optional(),
+    parentSessionId: z.string().optional(),
+    detectionSource: z.literal("claude-hook").optional(),
+  })
+  .passthrough();

package/src/api/schemas/webhooks/codex.ts

@@ -0,0 +1,34 @@
+import { z } from "@hono/zod-openapi";
+
+// Minimal validation: only 'sessionId' is essential. All other fields are optional
+// and extra fields pass through transparently (.passthrough()) so future changes
+// to the Codex hook format don't cause unexpected rejections.
+export const CodexWebhookBodySchema = z
+  .object({
+    sessionId: z.string().openapi({ example: "abc-123-def" }),
+    eventType: z.string().optional().openapi({ example: "PreToolUse" }),
+    eventTime: z.number().optional(),
+    hookSeq: z.number().optional(),
+    state: z.enum(["working", "idle", "waiting-input", "error", "shell", "unknown"]).optional(),
+    hasAttention: z.boolean().optional(),
+    attentionKind: z.enum(["permission", "question", "turn", "none"]).optional(),
+    summary: z.string().optional(),
+    activeTool: z.string().optional(),
+    model: z.string().optional(),
+    toolName: z.string().optional(),
+    toolInputSummary: z.string().optional(),
+    toolResultStatus: z.enum(["started", "completed", "error", "blocked", "denied", "unknown"]).optional(),
+    permissionMode: z.string().optional(),
+    startSource: z.string().optional(),
+    endReason: z.string().optional(),
+    transcriptPath: z.string().optional(),
+    currentPath: z.string().optional(),
+    lastActivity: z.number().optional(),
+    parentSessionId: z.string().optional(),
+    forkedFromId: z.string().optional(),
+    turnId: z.string().optional(),
+    agentId: z.string().optional(),
+    agentType: z.string().optional(),
+    detectionSource: z.literal("codex-hook").optional(),
+  })
+  .passthrough();

package/src/api/schemas/webhooks/opencode.ts

@@ -0,0 +1,29 @@
+import { z } from "@hono/zod-openapi";
+
+// Minimal validation: only 'event' is essential. All other fields are optional
+// and extra fields pass through transparently (.passthrough()) so future changes
+// to the OpenCode hook format don't cause unexpected rejections.
+export const OpencodeWebhookBodySchema = z
+  .object({
+    event: z.string().openapi({ example: "session.status" }),
+    sessionID: z.string().optional().openapi({ example: "ses_abc123" }),
+    directory: z.string().optional().openapi({ example: "/home/user/project" }),
+    title: z.string().optional().openapi({ example: "My session" }),
+    permissionID: z.string().optional(),
+    info: z
+      .object({
+        id: z.string().optional(),
+        title: z.string().optional(),
+        directory: z.string().optional(),
+        parentID: z.string().optional(),
+        time: z
+          .object({
+            created: z.number().optional(),
+            updated: z.number().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    status: z.object({ type: z.string().optional() }).optional(),
+  })
+  .passthrough();

package/src/api/services/claude-session.ts

@@ -0,0 +1,9 @@
+export const STATE_BEARING_EVENTS = new Set([
+  "SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest",
+  "PermissionDenied", "PostToolUse", "PostToolUseFailure", "PostToolBatch",
+  "Stop", "StopFailure", "SubagentStart", "SubagentStop", "SessionEnd",
+]);
+
+export function isMetadataOnlyEvent(eventType: string): boolean {
+  return !STATE_BEARING_EVENTS.has(eventType);
+}

package/src/api/services/codex-session.ts

@@ -0,0 +1,8 @@
+export const STATE_BEARING_EVENTS = new Set([
+  "SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest",
+  "PostToolUse", "SubagentStart", "SubagentStop", "Stop",
+]);
+
+export function isMetadataOnlyEvent(eventType: string): boolean {
+  return !STATE_BEARING_EVENTS.has(eventType);
+}

package/src/api/services/opencode-session.ts

@@ -0,0 +1,73 @@
+import type { SessionModel } from "../../shared/types";
+import type { OpencodeWebhookPayload, HookStateResult } from "../models/opencode";
+
+export function mapHookState(
+  event: string,
+  payload: OpencodeWebhookPayload,
+  existing?: SessionModel,
+): HookStateResult {
+  const prevCount = (existing?.opencode?.pendingAttentionCount ?? 0);
+  let nextCount = prevCount;
+
+  if (event === "permission.updated" || event === "permission.asked" || event === "question.asked") {
+    nextCount = prevCount + 1;
+  } else if (event === "permission.replied" || event === "question.replied") {
+    nextCount = Math.max(0, prevCount - 1);
+  }
+
+  const hasAttention = nextCount > 0;
+
+  if (event === "session.error") {
+    return { state: "error", hasAttention: false, pendingAttentionCount: 0 };
+  }
+
+  if (hasAttention) {
+    return { state: "waiting-input", hasAttention: true, pendingAttentionCount: nextCount };
+  }
+
+  if (event === "session.status" && payload.status?.type) {
+    return {
+      state: (payload.status.type === "busy" || payload.status.type === "retry") ? "working" : "idle",
+      hasAttention: false,
+      pendingAttentionCount: nextCount,
+    };
+  }
+
+  if (event === "session.idle") {
+    return { state: "idle", hasAttention: false, pendingAttentionCount: nextCount };
+  }
+
+  if (event === "permission.replied" || event === "question.replied") {
+    return { state: existing?.state === "waiting-input" ? "idle" : (existing?.state ?? "idle"), hasAttention: false, pendingAttentionCount: nextCount };
+  }
+
+  return {
+    state: existing?.state ?? "idle",
+    hasAttention,
+    pendingAttentionCount: nextCount,
+  };
+}
+
+export function extractSessionParentId(
+  event: string,
+  payload: OpencodeWebhookPayload,
+  existing?: SessionModel,
+): string | undefined {
+  if (event !== "session.created" && event !== "session.updated") {
+    return existing?.parentSessionId;
+  }
+
+  const parentID = payload.info?.parentID;
+  if (!parentID) {
+    return existing?.parentSessionId;
+  }
+
+  // Only treat real session ids as parent sessions. Other event payloads may
+  // include message-part ancestry such as msg_* ids, which would incorrectly
+  // reclassify a root session as a hidden child row.
+  if (!parentID.startsWith("ses_")) {
+    return existing?.parentSessionId;
+  }
+
+  return `opencode:${parentID}`;
+}

package/src/classifier.ts

@@ -0,0 +1,206 @@
+import { detectTool, getPreviewMatchPositions, previewSignals } from "./detect";
+import type {
+  DetectionReason,
+  EnrichedPaneRecord,
+  PaneModel,
+  PaneSample,
+  PaneState,
+  ProcessInfo,
+  SnapshotHistory,
+  ToolKind,
+} from "./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,
+    });
+    return { state: waitingReason ? "waiting-input" : "idle", reasons: waitingReason ? [...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) {
+    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;
+}