@jinn-network/client 0.1.9 → 0.2.0

package/node_modules/@jinn-network/core/dist/trajectory/schema.js

@@ -0,0 +1,110 @@
+/**
+ * jinn.trajectory.v1 — OTLP-JSON-shaped trace blob signed and uploaded once
+ * per run. Scope: docs/superpowers/specs/2026-04-23-jinn-execution-envelope-tee-scope.md
+ * §3.1 trajectory row + K6 span profile, §4.3 trajectory profile deliverable.
+ *
+ * Each span carries jinn.prevSpanHash (in-run hash chain) + jinn.span.kind
+ * (normative profile). Secret-scrub (§4.3 V1 minimum) produces a run-level
+ * redactionManifest signed alongside the spans.
+ */
+import { z } from 'zod/v3';
+const HexStringSchema = z.string().regex(/^0x[0-9a-fA-F]*$/);
+export const JinnSpanKindSchema = z.enum([
+    'jinn.phase',
+    'jinn.llm_call',
+    'jinn.mcp_call',
+    'jinn.artifact.emit',
+    'jinn.venue_io',
+    'jinn.state_transition',
+    'jinn.agent_turn',
+    'jinn.tool_call',
+]);
+const EventSchema = z.object({
+    timeUnixNano: z.string(),
+    name: z.string(),
+    attributes: z.record(z.unknown()).optional(),
+});
+const SpanStatusSchema = z.object({
+    code: z.enum(['UNSET', 'OK', 'ERROR']),
+    message: z.string().optional(),
+});
+/** An OTLP-shaped span with Jinn-required attributes. */
+export const SpanSchema = z.object({
+    traceId: z.string().regex(/^[0-9a-f]{32}$/),
+    spanId: z.string().regex(/^[0-9a-f]{16}$/),
+    parentSpanId: z.string().regex(/^[0-9a-f]{16}$/).nullable(),
+    name: z.string().min(1),
+    kind: z.enum(['INTERNAL', 'CLIENT', 'SERVER', 'PRODUCER', 'CONSUMER']),
+    startTimeUnixNano: z.string(),
+    endTimeUnixNano: z.string(),
+    attributes: z
+        .record(z.unknown())
+        .refine((a) => typeof a['jinn.span.kind'] === 'string', {
+        message: 'jinn.span.kind attribute required',
+    })
+        .refine((a) => typeof a['jinn.prevSpanHash'] === 'string', {
+        message: 'jinn.prevSpanHash attribute required',
+    }),
+    events: z.array(EventSchema),
+    status: SpanStatusSchema,
+});
+export const RedactionManifestSchema = z
+    .object({
+    spans: z.array(z.object({
+        spanId: z.string().regex(/^[0-9a-f]{16}$/),
+        redactedKeys: z.array(z.string()),
+    })),
+    totalRedactions: z.number().int().nonnegative(),
+})
+    .refine((m) => m.spans.reduce((acc, s) => acc + s.redactedKeys.length, 0) === m.totalRedactions, { message: 'totalRedactions must equal sum of per-span redactedKeys' });
+const SignatureSchema = z.object({
+    algo: z.literal('secp256k1'),
+    signer: HexStringSchema,
+    hash: HexStringSchema,
+    sig: HexStringSchema,
+});
+export const JinnTrajectoryV1Schema = z.object({
+    schemaVersion: z.literal('jinn.trajectory.v1'),
+    runId: z.string().min(1),
+    parentEnvelopeCid: z.string().nullable(),
+    spans: z.array(SpanSchema),
+    redactionManifest: RedactionManifestSchema,
+    signature: SignatureSchema,
+});
+/** Unsigned form — what we hash + sign. */
+export const UnsignedTrajectorySchema = JinnTrajectoryV1Schema.omit({ signature: true });
+/**
+ * Per-run capture manifest — records the operator's authorisation and
+ * coarse harness-bundle metadata for telemetry capture. v0 deliberately
+ * keeps operator control at the bundle level (no per-file curation) per
+ * DR-2026-05-07-g; the audit surface is "what did the operator authorise
+ * the daemon to read?" not "what did the daemon ultimately read?"
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §3.3
+ */
+export const CaptureManifestSchema = z.object({
+    scrubProcessors: z.array(z.object({
+        name: z.string(),
+        version: z.string(),
+        config: z.record(z.unknown()).optional(),
+    })),
+    reviewedBy: z.object({
+        safeAddress: z.string(),
+        reviewedAt: z.string().datetime(),
+    }),
+    trustedRepoToggle: z.boolean(),
+    harnessBundle: z.object({
+        included: z.boolean(),
+        sha256: z.string().regex(/^[0-9a-f]{64}$/),
+        allowedDirectoriesHash: z.string().regex(/^[0-9a-f]{64}$/),
+        capturePath: z.enum(['A', 'B', 'C', 'D']),
+    }),
+    /**
+     * The single `share` consent (mono#1714): may a mined task be published off
+     * the box (enforced at the mint publish gate). Local retention is
+     * unconditional, so there is no separate retention-consent field.
+     */
+    publishMinedTasksConsent: z.boolean().optional().default(false),
+});
+/** sha256 of an empty (no-files) bundle. Used when the operator opts out of harness-bundle capture. */
+export const EMPTY_BUNDLE_SHA256 = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';

package/node_modules/@jinn-network/core/dist/trajectory/transcript-parsers/aider-history.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Aider history parser.
+ *
+ * Aider records two transcript flavours:
+ *
+ *   1. `.aider.analytics.log.jsonl` (preferred; emitted when --analytics-log
+ *      is enabled). One JSON record per line. Common events:
+ *        - { event: 'message_send', role: 'user', content }   → user-message
+ *        - { event: 'model_response', role: 'assistant', content } → assistant-message
+ *        - { event: 'edit', path, diff }                      → edit
+ *
+ *   2. `.aider.chat.history.md` (fallback; always emitted by Aider). A
+ *      timestamped markdown log:
+ *        # 2026-05-07 00:00:00 +0000
+ *
+ *        > user message
+ *
+ *        assistant reply text
+ *
+ * The parser dispatches on file extension: `.jsonl` → analytics path; `.md`
+ * (or anything else) → markdown path. Both produce canonical TranscriptEvents.
+ *
+ * For the JSONL path, `parseChunk` follows the streaming pattern (preserves
+ * any incomplete trailing line). For the markdown path, `parseChunk` is a
+ * no-op — markdown is not line-stable, so the watcher polls and replays
+ * `parseFull`.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class AiderHistoryParser implements TranscriptParser {
+    readonly tool: "aider";
+    private buffer;
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-parsers/aider-history.js

@@ -0,0 +1,181 @@
+/**
+ * Aider history parser.
+ *
+ * Aider records two transcript flavours:
+ *
+ *   1. `.aider.analytics.log.jsonl` (preferred; emitted when --analytics-log
+ *      is enabled). One JSON record per line. Common events:
+ *        - { event: 'message_send', role: 'user', content }   → user-message
+ *        - { event: 'model_response', role: 'assistant', content } → assistant-message
+ *        - { event: 'edit', path, diff }                      → edit
+ *
+ *   2. `.aider.chat.history.md` (fallback; always emitted by Aider). A
+ *      timestamped markdown log:
+ *        # 2026-05-07 00:00:00 +0000
+ *
+ *        > user message
+ *
+ *        assistant reply text
+ *
+ * The parser dispatches on file extension: `.jsonl` → analytics path; `.md`
+ * (or anything else) → markdown path. Both produce canonical TranscriptEvents.
+ *
+ * For the JSONL path, `parseChunk` follows the streaming pattern (preserves
+ * any incomplete trailing line). For the markdown path, `parseChunk` is a
+ * no-op — markdown is not line-stable, so the watcher polls and replays
+ * `parseFull`.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import { readFile } from 'node:fs/promises';
+export class AiderHistoryParser {
+    tool = 'aider';
+    buffer = '';
+    parseChunk(input) {
+        // parseChunk is the streaming-friendly path; only meaningful for the
+        // JSONL analytics format. Callers wiring the markdown fallback through
+        // a watcher poll the file and re-run parseFull.
+        const text = typeof input.chunk === 'string' ? input.chunk : input.chunk.toString('utf-8');
+        this.buffer += text;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const event = analyticsRecordToEvent(record);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    async parseFull(input) {
+        const lower = input.path.toLowerCase();
+        if (lower.endsWith('.jsonl')) {
+            const text = await readFile(input.path, 'utf-8');
+            const normalised = text.endsWith('\n') ? text : text + '\n';
+            const previousBuffer = this.buffer;
+            this.buffer = '';
+            try {
+                return this.parseChunk({ sessionId: input.sessionId, chunk: normalised });
+            }
+            finally {
+                this.buffer = previousBuffer;
+            }
+        }
+        // Markdown fallback (.md or otherwise).
+        const text = await readFile(input.path, 'utf-8');
+        return parseMarkdownHistory(text);
+    }
+}
+function analyticsRecordToEvent(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const ts = record.ts ?? record.timestamp;
+    if (typeof ts !== 'string')
+        return null;
+    const event = record.event;
+    if (event === 'message_send' || record.role === 'user') {
+        if (typeof record.content !== 'string')
+            return null;
+        return { kind: 'user-message', timestamp: ts, content: record.content };
+    }
+    if (event === 'model_response' || record.role === 'assistant') {
+        if (typeof record.content !== 'string')
+            return null;
+        return { kind: 'assistant-message', timestamp: ts, content: record.content };
+    }
+    if (event === 'edit') {
+        if (typeof record.path !== 'string' || typeof record.diff !== 'string')
+            return null;
+        return { kind: 'edit', timestamp: ts, path: record.path, diff: record.diff };
+    }
+    return null;
+}
+/**
+ * Best-effort markdown chat-history parser. The format is human-friendly and
+ * not designed for round-tripping; we split on date headings (`# YYYY-MM-DD ...`)
+ * and within each block treat lines starting with `> ` as user messages and
+ * the remaining non-empty text as the assistant reply.
+ */
+function parseMarkdownHistory(text) {
+    const events = [];
+    const lines = text.split('\n');
+    let currentTs = null;
+    let userBuf = [];
+    let assistantBuf = [];
+    let mode = 'idle';
+    const flush = () => {
+        if (!currentTs) {
+            userBuf = [];
+            assistantBuf = [];
+            mode = 'idle';
+            return;
+        }
+        if (userBuf.length > 0) {
+            const content = userBuf.join('\n').trim();
+            if (content) {
+                events.push({ kind: 'user-message', timestamp: currentTs, content });
+            }
+        }
+        if (assistantBuf.length > 0) {
+            const content = assistantBuf.join('\n').trim();
+            if (content) {
+                events.push({ kind: 'assistant-message', timestamp: currentTs, content });
+            }
+        }
+        userBuf = [];
+        assistantBuf = [];
+        mode = 'idle';
+    };
+    for (const line of lines) {
+        const headingMatch = /^#\s+(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})/.exec(line);
+        if (headingMatch) {
+            flush();
+            // Normalise to ISO 8601 UTC. The header includes a tz offset which we
+            // drop here for v0; downstream ingest only needs a parseable timestamp.
+            currentTs = `${headingMatch[1]}T${headingMatch[2]}.000Z`;
+            continue;
+        }
+        if (line.startsWith('> ')) {
+            // Switch into user-message mode. If we were previously in assistant
+            // mode, flush the assistant buffer as the previous turn's reply.
+            if (mode === 'assistant') {
+                if (currentTs) {
+                    const content = assistantBuf.join('\n').trim();
+                    if (content) {
+                        events.push({ kind: 'assistant-message', timestamp: currentTs, content });
+                    }
+                }
+                assistantBuf = [];
+            }
+            mode = 'user';
+            userBuf.push(line.slice(2));
+            continue;
+        }
+        if (line.startsWith('>')) {
+            // Continuation of a user message ("> ").
+            if (mode === 'user')
+                userBuf.push(line.slice(1));
+            continue;
+        }
+        if (mode === 'user' && line.trim() === '') {
+            // Blank line ends the user block; assistant text (if any) follows.
+            mode = 'assistant';
+            continue;
+        }
+        if (mode === 'assistant' || (mode === 'idle' && currentTs && line.trim() !== '')) {
+            mode = 'assistant';
+            assistantBuf.push(line);
+        }
+    }
+    flush();
+    return events;
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-parsers/claude-code-jsonl.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Claude Code JSONL transcript parser.
+ *
+ * Reads `~/.claude/projects/<project>/<session-id>.jsonl` line-by-line, mapping
+ * per-record content to canonical TranscriptEvent shapes (Task 3.1):
+ *  - user record with string content              → user-message
+ *  - user record with tool_result content blocks  → tool-result
+ *  - assistant record with text content blocks    → assistant-message
+ *  - assistant record with tool_use content blocks → tool-call
+ *
+ * `parseChunk` preserves any incomplete trailing line across calls so the
+ * watcher (Task 3.9) can stream tail bytes without losing partial records.
+ * `parseFull` is a one-shot for `jinn capture import` and end-of-session
+ * safety-net ingest.
+ *
+ * Known v0 limitation: `tool-result.name` is filled from `tool_use_id` (the
+ * reference back to the originating call) rather than the actual tool name —
+ * resolving the name requires remembering each `tool_use` block's name across
+ * the stream. A follow-up will add that resolution map; for now, downstream
+ * consumers see a stable identifier even if it carries less display signal.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class ClaudeCodeJsonlParser implements TranscriptParser {
+    readonly tool: "claude-code";
+    private buffer;
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+    private recordToEvents;
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-parsers/claude-code-jsonl.js

@@ -0,0 +1,142 @@
+/**
+ * Claude Code JSONL transcript parser.
+ *
+ * Reads `~/.claude/projects/<project>/<session-id>.jsonl` line-by-line, mapping
+ * per-record content to canonical TranscriptEvent shapes (Task 3.1):
+ *  - user record with string content              → user-message
+ *  - user record with tool_result content blocks  → tool-result
+ *  - assistant record with text content blocks    → assistant-message
+ *  - assistant record with tool_use content blocks → tool-call
+ *
+ * `parseChunk` preserves any incomplete trailing line across calls so the
+ * watcher (Task 3.9) can stream tail bytes without losing partial records.
+ * `parseFull` is a one-shot for `jinn capture import` and end-of-session
+ * safety-net ingest.
+ *
+ * Known v0 limitation: `tool-result.name` is filled from `tool_use_id` (the
+ * reference back to the originating call) rather than the actual tool name —
+ * resolving the name requires remembering each `tool_use` block's name across
+ * the stream. A follow-up will add that resolution map; for now, downstream
+ * consumers see a stable identifier even if it carries less display signal.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import { readFile } from 'node:fs/promises';
+export class ClaudeCodeJsonlParser {
+    tool = 'claude-code';
+    buffer = '';
+    parseChunk(input) {
+        const text = typeof input.chunk === 'string' ? input.chunk : input.chunk.toString('utf-8');
+        this.buffer += text;
+        const lines = this.buffer.split('\n');
+        // Last fragment (no trailing newline) is preserved for the next chunk.
+        this.buffer = lines.pop() ?? '';
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                // Malformed line — skip silently. The watcher cannot recover bytes
+                // we drop, but a single corrupt line should not poison the stream.
+                continue;
+            }
+            events.push(...this.recordToEvents(record));
+        }
+        return events;
+    }
+    async parseFull(input) {
+        const text = await readFile(input.path, 'utf-8');
+        // Ensure the final record has a terminating newline so parseChunk drains it.
+        const normalised = text.endsWith('\n') ? text : text + '\n';
+        // parseFull is a one-shot. Use a fresh parser-like state to avoid leaking
+        // the buffer if a caller reuses the same instance for streaming + full.
+        const previousBuffer = this.buffer;
+        this.buffer = '';
+        try {
+            return this.parseChunk({ sessionId: input.sessionId, chunk: normalised });
+        }
+        finally {
+            this.buffer = previousBuffer;
+        }
+    }
+    recordToEvents(record) {
+        if (!record || typeof record.timestamp !== 'string')
+            return [];
+        const ts = record.timestamp;
+        if (record.type === 'user') {
+            const content = record.message?.content;
+            // String content is the canonical user message shape.
+            if (typeof content === 'string') {
+                return [{ kind: 'user-message', timestamp: ts, content }];
+            }
+            // Array content typically carries tool_result blocks (Claude Code emits
+            // tool responses inside a synthetic user turn). Other block types in a
+            // user-array record are skipped.
+            if (Array.isArray(content)) {
+                const out = [];
+                for (const block of content) {
+                    if (isToolResultBlock(block)) {
+                        const resultText = typeof block.content === 'string'
+                            ? block.content
+                            : JSON.stringify(block.content);
+                        out.push({
+                            kind: 'tool-result',
+                            timestamp: ts,
+                            // v0: use the reference id as `name`. Resolution-map upgrade
+                            // pending — see file header.
+                            name: block.tool_use_id,
+                            content: resultText,
+                            isError: block.is_error ?? false,
+                        });
+                    }
+                }
+                return out;
+            }
+            return [];
+        }
+        if (record.type === 'assistant') {
+            const content = record.message?.content;
+            const blocks = Array.isArray(content)
+                ? content
+                : typeof content === 'string'
+                    ? [{ type: 'text', text: content }]
+                    : [];
+            const out = [];
+            for (const block of blocks) {
+                if (isTextBlock(block)) {
+                    out.push({ kind: 'assistant-message', timestamp: ts, content: block.text });
+                }
+                else if (isToolUseBlock(block)) {
+                    out.push({
+                        kind: 'tool-call',
+                        timestamp: ts,
+                        name: block.name,
+                        args: block.input ?? {},
+                    });
+                }
+                // `thinking` and any other unrecognised block types are intentionally
+                // dropped — the canonical TranscriptEvent shape doesn't carry them and
+                // including them would violate downstream identity-scrub assumptions.
+            }
+            return out;
+        }
+        // Records with unknown `type` (e.g. queue-operation, summary) are dropped.
+        return [];
+    }
+}
+function isTextBlock(block) {
+    return block.type === 'text' && typeof block.text === 'string';
+}
+function isToolUseBlock(block) {
+    return (block.type === 'tool_use' &&
+        typeof block.name === 'string' &&
+        typeof block.id === 'string');
+}
+function isToolResultBlock(block) {
+    return (block.type === 'tool_result' &&
+        typeof block.tool_use_id === 'string');
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-parsers/codex-session.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Codex CLI session transcript parser.
+ *
+ * Reads `~/.codex/sessions/<id>.jsonl` line-by-line, mapping per-record content
+ * to canonical TranscriptEvent shapes (Task 3.1):
+ *  - role: 'user' with string content       → user-message
+ *  - role: 'assistant' with string content  → assistant-message
+ *  - role: 'function' with function_call    → tool-call (also: assistant with
+ *    a top-level function_call field)
+ *  - role: 'tool' with content               → tool-result
+ *
+ * Codex CLI 0.129.0+ wraps each line as `{ timestamp, type, payload }` where
+ * `type` is `session_meta`, `turn_context`, `response_item`, or `event_msg`.
+ * Tool calls and messages live inside `payload` (e.g. `function_call`,
+ * `function_call_output`, `message` with `input_text` / `output_text` blocks).
+ * Older sessions use a flat per-line shape with `role` at the top level; both
+ * are detected by record shape.
+ *
+ * `parseChunk` preserves any incomplete trailing line across calls so the
+ * watcher (Task 3.9) can stream tail bytes without losing partial records.
+ *
+ * Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §4.2 path B.
+ */
+import type { TranscriptEvent, TranscriptParser } from './types.js';
+export declare class CodexSessionParser implements TranscriptParser {
+    readonly tool: "codex";
+    private buffer;
+    /** Maps function_call `call_id` → tool name for function_call_output rows. */
+    private callNames;
+    parseChunk(input: {
+        sessionId: string;
+        chunk: Buffer | string;
+    }): TranscriptEvent[];
+    parseFull(input: {
+        sessionId: string;
+        path: string;
+    }): Promise<TranscriptEvent[]>;
+    private lineToEvents;
+    private wrappedEnvelopeToEvents;
+    private responseItemToEvents;
+    private recordToEvents;
+}