@tangle-network/harness-sessions 0.1.1 → 0.1.3

package/README.md

@@ -12,7 +12,7 @@ npm install @tangle-network/harness-sessions
 
 ## Where this fits
 
-- The sidecar's harness session contract (agent-dev-container `packages/cli-agent-registry`) imports `STORES` and `SessionFormatId` from here; it keeps no second copy of where a harness writes.
+- The sidecar's harness session contract (agent-container `packages/cli-agent-registry`) imports `STORES` and `SessionFormatId` from here; it keeps no second copy of where a harness writes.
 - The capture path reads captures through `listCapture` / `readCapture`.
 - Discovery's trace gate, agent-eval, agent-record and the blog read sessions only through this package.
 - Its only dependencies are `@tangle-network/agent-trace-contract` and Node built-ins (`node:sqlite` for OpenCode).

package/dist/formats/claude-code.js

@@ -14,6 +14,7 @@ import { fileRecords } from '../source.js';
 import { runFold } from './fold.js';
 import { EVIDENCE, STORES, mtimeMs, storeGlob, walkFiles } from '../stores.js';
 import { headRecord } from './head.js';
+import { claudeRecordIsMachine, claudeTypedPromptText } from './claude-records.js';
 const FORMAT = 'claude-code.projects-jsonl';
 const STORE = STORES[FORMAT];
 const HARNESS = 'claude-code';
@@ -29,6 +30,12 @@ function usageOf(value) {
         cacheWrite: count(value.cache_creation_input_tokens),
     });
 }
+function firstText(parts) {
+    for (const part of parts)
+        if (part.type === 'text')
+            return part.text;
+    return '';
+}
 const INTERRUPTED = /^\[Request interrupted by user/u;
 export function createFold(ref, mode, stats) {
     const subagent = ref.parentNativeSessionId !== null;
@@ -37,6 +44,8 @@ export function createFold(ref, mode, stats) {
     let aborted = null;
     let errors = 0;
     let identified = false;
+    // A resumed agent's file writes its earlier records again, each with the uuid it had.
+    const seenUuids = new Set();
     const observe = (record) => {
         if (!subagent && record.isSidechain === true) {
             sidechainSkipped += 1;
@@ -45,6 +54,11 @@ export function createFold(ref, mode, stats) {
         const type = record.type;
         if (type !== 'user' && type !== 'assistant' && type !== 'system')
             return;
+        if (typeof record.uuid === 'string') {
+            if (seenUuids.has(record.uuid))
+                return;
+            seenUuids.add(record.uuid);
+        }
         const at = builder.seen(record.timestamp);
         if (builder.cwd === null && typeof record.cwd === 'string')
             builder.cwd = record.cwd;
@@ -60,6 +74,7 @@ export function createFold(ref, mode, stats) {
             }
         }
         const uuid = str(record.uuid) ?? `${builder.nativeSessionId}:${stats.line}`;
+        const machine = (text) => claudeRecordIsMachine({ text, isMeta: record.isMeta === true, isCompactSummary: record.isCompactSummary === true, entrypoint: str(record.entrypoint) ?? undefined });
         if (type === 'system') {
             if (record.subtype !== 'api_error')
                 return;
@@ -95,10 +110,10 @@ export function createFold(ref, mode, stats) {
                 builder.message({
                     id: uuid,
                     role: 'user',
-                    actor: record.isMeta === true || record.isCompactSummary === true ? 'injected' : subagent ? 'subagent-spawn' : 'human',
+                    actor: machine(content) ? 'injected' : subagent ? 'subagent-spawn' : 'human',
                     at,
                     modelCallId: null,
-                    parts: [{ type: 'text', text: content }],
+                    parts: [{ type: 'text', text: machine(content) ? content : claudeTypedPromptText(content) }],
                 });
                 return;
             }
@@ -129,7 +144,7 @@ export function createFold(ref, mode, stats) {
                 else if (block.type === 'text' && typeof block.text === 'string') {
                     if (INTERRUPTED.test(block.text))
                         aborted = { at };
-                    userParts.push({ type: 'text', text: block.text });
+                    userParts.push({ type: 'text', text: claudeTypedPromptText(block.text) });
                 }
                 else if (block.type === 'image' || block.type === 'document') {
                     const source = isRecord(block.source) ? block.source : {};
@@ -142,7 +157,7 @@ export function createFold(ref, mode, stats) {
                 builder.message({
                     id: uuid,
                     role: 'user',
-                    actor: record.isMeta === true ? 'injected' : subagent ? 'subagent-spawn' : 'human',
+                    actor: machine(firstText(userParts)) ? 'injected' : subagent ? 'subagent-spawn' : 'human',
                     at,
                     modelCallId: null,
                     parts: userParts,

package/dist/formats/claude-records.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Which Claude Code `user` records a person typed and which the harness wrote. Claude Code stores
+ * both as `type: "user"`; the markers below are the only difference. This is the one owner of the
+ * rule, so every reader of a Claude Code transcript (traces, agent-eval) classifies turns alike.
+ */
+export interface ClaudeRecordFacts {
+    /** The record's text (the first text part for block content). */
+    text: string;
+    isMeta?: boolean | undefined;
+    isCompactSummary?: boolean | undefined;
+    /** The record's `entrypoint`; `sdk-cli` is a programmatic caller, not a person. */
+    entrypoint?: string | undefined;
+}
+/** True when the harness, not a person, wrote this user record. */
+export declare function claudeRecordIsMachine(facts: ClaudeRecordFacts): boolean;
+/**
+ * What a person typed. A slash command is stored as a `<command-name>` wrapper; this returns the
+ * command and its arguments (`/effort`, `/model opus`). Text without a wrapper is unchanged.
+ */
+export declare function claudeTypedPromptText(text: string): string;

package/dist/formats/claude-records.js

@@ -0,0 +1,34 @@
+/**
+ * Which Claude Code `user` records a person typed and which the harness wrote. Claude Code stores
+ * both as `type: "user"`; the markers below are the only difference. This is the one owner of the
+ * rule, so every reader of a Claude Code transcript (traces, agent-eval) classifies turns alike.
+ */
+const MACHINE_TEXT_PREFIXES = [
+    '<local-command-caveat>',
+    '<local-command-stdout>',
+    '<local-command-stderr>',
+    'Caveat: The messages below',
+    '<task-notification>',
+    '<bash-stdout>',
+    '<bash-stderr>',
+    '<user-prompt-submit-hook>',
+    '[Request interrupted by user',
+];
+/** True when the harness, not a person, wrote this user record. */
+export function claudeRecordIsMachine(facts) {
+    if (facts.isMeta === true || facts.isCompactSummary === true || facts.entrypoint === 'sdk-cli')
+        return true;
+    const head = facts.text.trimStart();
+    return MACHINE_TEXT_PREFIXES.some((prefix) => head.startsWith(prefix));
+}
+/**
+ * What a person typed. A slash command is stored as a `<command-name>` wrapper; this returns the
+ * command and its arguments (`/effort`, `/model opus`). Text without a wrapper is unchanged.
+ */
+export function claudeTypedPromptText(text) {
+    const name = /<command-name>([\s\S]*?)<\/command-name>/u.exec(text)?.[1]?.trim();
+    if (!name)
+        return text;
+    const args = /<command-args>([\s\S]*?)<\/command-args>/u.exec(text)?.[1]?.trim();
+    return args ? `${name} ${args}` : name;
+}

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { HARNESS_SESSION_SCHEMA } from './schema.js';
 export { EVIDENCE, SESSION_FORMAT_IDS, STORES, assertStoreRoot, storeGlob } from './catalog.js';
 export { knownHarnesses, listReaders, maybeReaderFor, readerFor, readerForFormat } from './registry.js';
 export { claudeCodeReader, claudeCodeRefForFile } from './formats/claude-code.js';
+export { claudeRecordIsMachine, claudeTypedPromptText, type ClaudeRecordFacts } from './formats/claude-records.js';
 export { codexReader, codexRefForFile } from './formats/codex.js';
 export { opencodeReader, opencodeSessionsInStore } from './formats/opencode.js';
 export { piReader, piRefForFile } from './formats/pi.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export { HARNESS_SESSION_SCHEMA } from './schema.js';
 export { EVIDENCE, SESSION_FORMAT_IDS, STORES, assertStoreRoot, storeGlob } from './catalog.js';
 export { knownHarnesses, listReaders, maybeReaderFor, readerFor, readerForFormat } from './registry.js';
 export { claudeCodeReader, claudeCodeRefForFile } from './formats/claude-code.js';
+export { claudeRecordIsMachine, claudeTypedPromptText } from './formats/claude-records.js';
 export { codexReader, codexRefForFile } from './formats/codex.js';
 export { opencodeReader, opencodeSessionsInStore } from './formats/opencode.js';
 export { piReader, piRefForFile } from './formats/pi.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/harness-sessions",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "One reader for every coding-agent harness's native session (Claude Code, Codex, OpenCode, Pi): store layouts, a normalized session with messages, tool calls, served models, usage and ending errors, and projections to chat messages, OTLP spans and turns",
   "type": "module",
   "sideEffects": false,