@snoai/mem-claude 1.1.0 → 1.2.0

package/dist/hooks.js

@@ -8,6 +8,7 @@ import { importReceiptExists, importRepository } from "./import.js";
 import { connectMemory, isDegradedConnection } from "./memory-client.js";
 import { withinDeadline, } from "./recall.js";
 import { hookScope, workspaceRoot } from "./scope.js";
+import { reportSessionActivity } from "./session-activity.js";
 import { readSkillRuns } from "./skill-runs.js";
 import { startWorkerDetached } from "./worker.js";
 import { appendSpool, readLastSession, readSession, recordDegraded, recordInjection, recordInvocation, recordLookup, recordSkip, writeLastSession, updateSession, writeSession, } from "./session-state.js";
@@ -21,7 +22,7 @@ const promptSchema = baseHookSchema.extend({ prompt_id: z.string().min(1), promp
 const sessionEndSchema = baseHookSchema.extend({ transcript_path: z.string().optional(), reason: z.string().optional() });
 const toolSchema = baseHookSchema.extend({ tool_use_id: z.string().min(1), tool_name: z.string().min(1), tool_input: z.unknown() });
 const postToolSchema = toolSchema.extend({ tool_response: z.unknown() });
-const stopSchema = baseHookSchema.extend({ prompt_id: z.string().min(1), last_assistant_message: z.string() });
+const stopSchema = baseHookSchema.extend({ prompt_id: z.string().min(1), last_assistant_message: z.string(), transcript_path: z.string().optional() });
 function emptyEnvelope(event) {
     return JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: "" } });
 }
@@ -188,6 +189,23 @@ export async function userPromptSubmit(raw) {
         return emptyEnvelope("UserPromptSubmit");
     }
 }
+/** Sends one session.activity row for the records since the last send; a failure is logged and never stops the hook. */
+async function sendSessionActivity(input, hook) {
+    try {
+        const state = await readSession(input.session_id);
+        await reportSessionActivity(state.activity, input, hook, async (activity) => {
+            state.activity = activity;
+            await writeSession(state);
+        });
+    }
+    catch (error) {
+        console.error(JSON.stringify({
+            event: "session-activity",
+            reason: error instanceof Error ? error.message : String(error),
+            impact: `no session.activity row for this ${hook}; the next send covers the same records`,
+        }));
+    }
+}
 export async function stop(raw) {
     const started = performance.now();
     let sessionId;
@@ -198,6 +216,7 @@ export async function stop(raw) {
             await persistSkip(input.session_id, "Stop", "subagent", started);
             return;
         }
+        await sendSessionActivity(input, "Stop");
         if (!readCaptureSettings().ambient)
             return;
         sessionId = input.session_id;
@@ -334,6 +353,7 @@ export async function sessionEnd(raw) {
             await persistSkip(input.session_id, "SessionEnd", "subagent", started);
             return;
         }
+        await sendSessionActivity(input, "SessionEnd");
         const state = await readSession(input.session_id);
         try {
             const rows = await readSkillRuns(input);

package/dist/session-activity.d.ts

@@ -0,0 +1,11 @@
+import { type ActivityCursor, type ActivityRecord } from "@snoai/memory/coding-skin";
+export declare function claudeRecord(line: string): ActivityRecord | undefined;
+/**
+ * Appends one session.activity row for the transcript records after the cursor, and returns the advanced cursor. Stop leaves the run open; SessionEnd closes it.
+ * `persist` saves the advanced cursor before the row is appended, so a failed save repeats the window instead of counting it twice.
+ */
+export declare function reportSessionActivity(cursor: ActivityCursor | undefined, input: {
+    session_id: string;
+    cwd: string;
+    transcript_path?: string | undefined;
+}, hook: "Stop" | "SessionEnd", persist?: (cursor: ActivityCursor) => Promise<void>): Promise<ActivityCursor>;

package/dist/session-activity.js

@@ -0,0 +1,91 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CODING_SKIN_HOOKS, appendObserveLedgerRows, EMPTY_ACTIVITY_CURSOR, foldActivity, isAgentText, readNewLines, } from "@snoai/memory/coding-skin";
+import { detectProjectId, getSnoProfileDir } from "@snoai/observability";
+import { z } from "zod";
+import { workspaceRoot } from "./scope.js";
+/** A quarter of the hook's timeout, so reading, the ledger write and the rest of the step stay within half of it; a backlog the budget cannot finish is read by the next send. */
+const readBudgetMs = (hook) => CODING_SKIN_HOOKS[hook].timeout * 1000 / 4;
+const entrySchema = z.object({
+    type: z.string(),
+    timestamp: z.string().optional(),
+    isMeta: z.boolean().optional(),
+    isSidechain: z.boolean().optional(),
+    isCompactSummary: z.boolean().optional(),
+    entrypoint: z.string().optional(),
+    origin: z.object({ kind: z.string() }).optional(),
+    message: z.object({ content: z.union([z.string(), z.array(z.unknown())]).optional() }).optional(),
+});
+const toolResultSchema = z.object({ type: z.literal("tool_result") });
+const textBlockSchema = z.object({ type: z.literal("text"), text: z.string() });
+/**
+ * Who sent a user entry, from Claude Code 2.1.x transcripts on the owner's machine. Heuristics:
+ * an entry the person typed has origin.kind "human" (older entries have no origin and count as
+ * typed), but Reach rings and seat starts are typed into the terminal too and are told apart by
+ * their text; a session whose entrypoint is "sdk-*" was started by a program, so every prompt in
+ * it comes from another agent; a "<teammate-message" (wrapped as "Another Claude session sent a message:") is another
+ * Claude session's message. Skill text (isMeta), the compaction or resume summary, local command
+ * output, "!" shell commands and their output, the interrupt marker and
+ * background-task notices other than a heartbeat tick change nothing.
+ */
+function incomingOf(entry) {
+    if (entry.type !== "user" || entry.isSidechain || entry.isMeta || entry.isCompactSummary)
+        return undefined;
+    const content = entry.message?.content;
+    const blocks = Array.isArray(content) ? content : [];
+    if (blocks.some(block => toolResultSchema.safeParse(block).success))
+        return undefined;
+    const text = (typeof content === "string" ? content : blocks.flatMap(block => {
+        const parsed = textBlockSchema.safeParse(block);
+        return parsed.success ? [parsed.data.text] : [];
+    }).join("\n")).trimStart();
+    if (text.startsWith("<task-notification>"))
+        return isAgentText(text) ? "agent" : undefined;
+    if (text.startsWith("<teammate-message") || text.startsWith("Another Claude session sent a message:"))
+        return "agent";
+    if (["<local-command-", "<bash-", "[Request interrupted by user"].some(prefix => text.startsWith(prefix)))
+        return undefined;
+    if (isAgentText(text) || entry.entrypoint?.startsWith("sdk"))
+        return "agent";
+    if (entry.origin !== undefined && entry.origin.kind !== "human")
+        return undefined;
+    return "human";
+}
+export function claudeRecord(line) {
+    const entry = entrySchema.parse(JSON.parse(line));
+    if (entry.timestamp === undefined)
+        return undefined;
+    const ts = Date.parse(entry.timestamp);
+    if (!Number.isFinite(ts))
+        throw new Error("invalid-transcript-timestamp");
+    const incoming = incomingOf(entry);
+    return incoming === undefined ? { ts } : { ts, incoming };
+}
+/**
+ * Appends one session.activity row for the transcript records after the cursor, and returns the advanced cursor. Stop leaves the run open; SessionEnd closes it.
+ * `persist` saves the advanced cursor before the row is appended, so a failed save repeats the window instead of counting it twice.
+ */
+export async function reportSessionActivity(cursor, input, hook, persist = async () => { }) {
+    const from = cursor ?? EMPTY_ACTIVITY_CURSOR;
+    const transcriptPath = input.transcript_path ?? join(process.env["CLAUDE_CONFIG_DIR"] ?? join(homedir(), ".claude"), "projects", input.cwd.replace(/[^a-zA-Z0-9]/g, "-"), `${input.session_id}.jsonl`);
+    const records = [];
+    const read = await readNewLines(transcriptPath, from.offset, readBudgetMs(hook), line => {
+        const record = claudeRecord(line);
+        if (record)
+            records.push(record);
+    });
+    // A backlog left unread means the session is not over as far as this send can tell.
+    const folded = foldActivity({ ...from, offset: read.offset }, records, hook === "SessionEnd" && read.done);
+    await persist(folded.cursor);
+    if (folded.payload) {
+        const projectId = input.cwd ? detectProjectId(await workspaceRoot(input.cwd)) : undefined;
+        appendObserveLedgerRows(getSnoProfileDir(), [{
+                ts_ms: folded.payload.window_end_ms,
+                ...(projectId === undefined ? {} : { project_id: projectId }),
+                event_type: "session.activity",
+                lane: "memory",
+                payload: { harness: "claude-code", ...folded.payload },
+            }]);
+    }
+    return folded.cursor;
+}

package/dist/session-state.d.ts

@@ -8,6 +8,7 @@ export declare function writeLastSession(project: string, sessionId: string, tra
 declare const sessionStateSchema: z.ZodObject<{
     sessionId: z.ZodString;
     skillRunsReported: z.ZodDefault<z.ZodNumber>;
+    activity: z.ZodOptional<z.ZodType<import("@snoai/memory/coding-skin").ActivityCursor, unknown, z.core.$ZodTypeInternals<import("@snoai/memory/coding-skin").ActivityCursor, unknown>>>;
     prompts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         prompt: z.ZodString;
         at: z.ZodNumber;

package/dist/session-state.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
+import { activityCursorSchema } from "@snoai/memory/coding-skin";
 import { z } from "zod";
 import { acquirePidFileLock, writeJsonAtomic } from "./files.js";
 import { appStateRoot, sessionPath, spoolDirectory } from "./paths.js";
@@ -35,6 +36,8 @@ const receiptEventSchema = z.object({
 const sessionStateSchema = z.object({
     sessionId: z.string().min(1),
     skillRunsReported: z.number().int().nonnegative().default(0),
+    /** Where the previous session.activity send stopped in the transcript. */
+    activity: activityCursorSchema.optional(),
     prompts: z.record(z.string(), z.object({ prompt: z.string(), at: z.number() })).default({}),
     receipt: z.record(z.string(), receiptEventSchema).default({}),
     /** PreToolUse arrival time by tool_use_id, consumed by PostToolUse to measure the call. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snoai/mem-claude",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "license": "Apache-2.0",
   "publishConfig": { "access": "public" },
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "apps/mem-claude"
   },
   "type": "module",
-  "description": "Thin Claude CLI client for Sno Station Mem.",
+  "description": "Give Claude Code a memory. It remembers what you worked on and brings it back next session.",
   "files": [
     "dist",
     "skills",
@@ -25,7 +25,7 @@
     "lint:fix": "biome check --write src/"
   },
   "dependencies": {
-    "@snoai/memory": "1.1.0",
+    "@snoai/memory": "^1.2.0",
     "fs-ext": "^2.1.1",
     "zod": "^4.5.4"
   },