@bububuger/spanory 0.1.14 → 0.1.16

package/dist/index.js

@@ -12,9 +12,11 @@ import { createCodexProxyServer } from './runtime/codex/proxy.js';
 import { openclawAdapter } from './runtime/openclaw/adapter.js';
 import { compileOtlp, parseHeaders, sendOtlp } from './otlp.js';
 import { loadUserEnv } from './env.js';
+import { waitForFileMtimeToSettle } from './runtime/shared/file-settle.js';
 import { langfuseBackendAdapter } from '../../backend-langfuse/dist/index.js';
 import { evaluateRules, loadAlertRules, sendAlertWebhook } from './alert/evaluate.js';
 import { summarizeCache, loadExportedEvents, summarizeAgents, summarizeCommands, summarizeMcp, summarizeSessions, summarizeTools, summarizeTurnDiff, } from './report/aggregate.js';
+import { loadIssueState, parsePendingTodoItems, resolveIssueStatePath, resolveTodoPath, saveIssueState, setIssueStatus, syncIssueState, } from './issue/state.js';
 const runtimeAdapters = {
     'claude-code': claudeCodeAdapter,
     codex: codexAdapter,
@@ -242,6 +244,23 @@ async function runHookMode(options) {
     if (!resolvedContext) {
         throw new Error('cannot resolve runtime context from hook payload; require session_id (or thread_id)');
     }
+    if (runtimeName === 'codex') {
+        const runtimeHome = resolveRuntimeHome(runtimeName, options.runtimeHome);
+        const transcriptPath = resolvedContext.transcriptPath
+            ?? (await listCodexSessions(runtimeHome)).find((session) => session.sessionId === resolvedContext.sessionId)?.transcriptPath;
+        if (transcriptPath) {
+            const settle = await waitForFileMtimeToSettle({
+                filePath: transcriptPath,
+                stableWindowMs: 350,
+                timeoutMs: 2500,
+                pollMs: 120,
+            });
+            resolvedContext.transcriptPath = transcriptPath;
+            if (!settle.settled) {
+                console.log(`hook=settle-timeout sessionId=${resolvedContext.sessionId} waitedMs=${settle.waitedMs}`);
+            }
+        }
+    }
     await runContextExportMode({
         runtimeName,
         context: resolvedContext,
@@ -821,11 +840,23 @@ function codexNotifyScriptContent({ spanoryBin, codexHome, exportDir, logFile })
         + `  echo "skip=empty-payload source=codex-notify args=$#" >> "${logFile}"\n`
         + '  exit 0\n'
         + 'fi\n'
+        + 'payload_file="$(mktemp "${TMPDIR:-/tmp}/spanory-codex-notify.XXXXXX")"\n'
+        + 'printf \'%s\' "$payload" > "$payload_file"\n'
         + `echo "$payload" | "${spanoryBin}" runtime codex hook \\\n`
         + '  --last-turn-only \\\n'
         + `  --runtime-home "${codexHome}" \\\n`
         + `  --export-json-dir "${exportDir}" \\\n`
-        + `  >> "${logFile}" 2>&1 || true\n`;
+        + `  >> "${logFile}" 2>&1 || true\n`
+        + '(\n'
+        + '  sleep 2\n'
+        + `  cat "$payload_file" | "${spanoryBin}" runtime codex hook \\\n`
+        + '    --last-turn-only \\\n'
+        + '    --force \\\n'
+        + `    --runtime-home "${codexHome}" \\\n`
+        + `    --export-json-dir "${exportDir}" \\\n`
+        + `    >> "${logFile}" 2>&1 || true\n`
+        + '  rm -f "$payload_file"\n'
+        + ') >/dev/null 2>&1 &\n';
 }
 async function applyCodexSetup({ homeRoot, spanoryBin, dryRun }) {
     const codexHome = path.join(homeRoot, '.codex');
@@ -1613,6 +1644,63 @@ alert
         process.exitCode = 2;
     }
 });
+const issue = program.command('issue').description('Manage local issue status for automation巡检');
+issue
+    .command('sync')
+    .description('Sync pending items from todo.md into issue state file')
+    .option('--todo-file <path>', 'Path to todo markdown file (default: ./todo.md)')
+    .option('--state-file <path>', 'Path to issue state json file (default: ./docs/issues/state.json)')
+    .action(async (options) => {
+    const todoFile = resolveTodoPath(options.todoFile);
+    const stateFile = resolveIssueStatePath(options.stateFile);
+    const todoRaw = await readFile(todoFile, 'utf-8');
+    const pending = parsePendingTodoItems(todoRaw, 'todo.md');
+    const prev = await loadIssueState(stateFile);
+    const result = syncIssueState(prev, pending);
+    await saveIssueState(stateFile, result.state);
+    console.log(JSON.stringify({
+        stateFile,
+        todoFile,
+        pending: pending.length,
+        added: result.added,
+        reopened: result.reopened,
+        autoClosed: result.autoClosed,
+        total: result.state.issues.length,
+    }, null, 2));
+});
+issue
+    .command('list')
+    .description('List issues from state file')
+    .option('--state-file <path>', 'Path to issue state json file (default: ./docs/issues/state.json)')
+    .option('--status <status>', 'Filter by status: open,in_progress,blocked,done')
+    .action(async (options) => {
+    const stateFile = resolveIssueStatePath(options.stateFile);
+    const state = await loadIssueState(stateFile);
+    const statusFilter = options.status ? String(options.status).trim() : '';
+    const rows = statusFilter
+        ? state.issues.filter((item) => item.status === statusFilter)
+        : state.issues;
+    console.log(JSON.stringify({ stateFile, total: rows.length, issues: rows }, null, 2));
+});
+issue
+    .command('set-status')
+    .description('Update one issue status in state file')
+    .requiredOption('--id <id>', 'Issue id, e.g. T2')
+    .requiredOption('--status <status>', 'Target status: open|in_progress|blocked|done')
+    .option('--note <text>', 'Optional status note')
+    .option('--state-file <path>', 'Path to issue state json file (default: ./docs/issues/state.json)')
+    .action(async (options) => {
+    const stateFile = resolveIssueStatePath(options.stateFile);
+    const prev = await loadIssueState(stateFile);
+    const next = setIssueStatus(prev, {
+        id: options.id,
+        status: options.status,
+        note: options.note,
+    });
+    await saveIssueState(stateFile, next);
+    const issueItem = next.issues.find((item) => item.id === options.id);
+    console.log(JSON.stringify({ stateFile, issue: issueItem }, null, 2));
+});
 program
     .command('hook')
     .description('Minimal hook entrypoint (defaults to runtime payload + ~/.env + default export dir)')

package/dist/issue/state.d.ts

@@ -0,0 +1,39 @@
+export declare const ISSUE_STATUSES: readonly ["open", "in_progress", "blocked", "done"];
+export type IssueStatus = (typeof ISSUE_STATUSES)[number];
+export interface IssueItem {
+    id: string;
+    title: string;
+    source: string;
+    status: IssueStatus;
+    notes: string[];
+    createdAt: string;
+    updatedAt: string;
+    closedAt?: string;
+}
+export interface IssueState {
+    version: 1;
+    updatedAt: string;
+    issues: IssueItem[];
+}
+export interface PendingTodoItem {
+    id: string;
+    title: string;
+    source: string;
+}
+export declare function parsePendingTodoItems(todoContent: string, source?: string): PendingTodoItem[];
+export declare function syncIssueState(prev: IssueState, pending: PendingTodoItem[], now?: string): {
+    state: IssueState;
+    added: number;
+    reopened: number;
+    autoClosed: number;
+};
+export declare function setIssueStatus(prev: IssueState, input: {
+    id: string;
+    status: string;
+    note?: string;
+}, now?: string): IssueState;
+export declare function createEmptyIssueState(now?: string): IssueState;
+export declare function loadIssueState(filePath: string): Promise<IssueState>;
+export declare function saveIssueState(filePath: string, state: IssueState): Promise<void>;
+export declare function resolveIssueStatePath(input?: string): string;
+export declare function resolveTodoPath(input?: string): string;

package/dist/issue/state.js

@@ -0,0 +1,151 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const ISSUE_STATUSES = ['open', 'in_progress', 'blocked', 'done'];
+function nowIso(now) {
+    return now ?? new Date().toISOString();
+}
+function normalizeId(id) {
+    return String(id ?? '').trim();
+}
+function assertStatus(status) {
+    if (!ISSUE_STATUSES.includes(status)) {
+        throw new Error(`unsupported issue status: ${status}`);
+    }
+}
+function assertAllowedTransition(from, to) {
+    if (from === to)
+        return;
+    if (from === 'done' && to !== 'done') {
+        throw new Error('cannot transition issue from done to non-done status');
+    }
+}
+export function parsePendingTodoItems(todoContent, source = 'todo.md') {
+    const lines = String(todoContent ?? '').split(/\r?\n/);
+    const items = [];
+    for (const line of lines) {
+        const m = line.match(/^\s*-\s*\[\s\]\s+([A-Za-z0-9_-]+)\s+(.*)$/);
+        if (!m)
+            continue;
+        items.push({
+            id: normalizeId(m[1]),
+            title: m[2].trim(),
+            source,
+        });
+    }
+    return items;
+}
+export function syncIssueState(prev, pending, now) {
+    const timestamp = nowIso(now);
+    const byId = new Map(prev.issues.map((issue) => [issue.id, issue]));
+    const activeIds = new Set(pending.map((item) => item.id));
+    let added = 0;
+    let reopened = 0;
+    let autoClosed = 0;
+    for (const item of pending) {
+        const existing = byId.get(item.id);
+        if (!existing) {
+            byId.set(item.id, {
+                id: item.id,
+                title: item.title,
+                source: item.source,
+                status: 'open',
+                notes: ['synced from todo pending item'],
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            });
+            added += 1;
+            continue;
+        }
+        existing.title = item.title;
+        existing.source = item.source;
+        existing.updatedAt = timestamp;
+        if (existing.status === 'done') {
+            existing.status = 'open';
+            existing.closedAt = undefined;
+            existing.notes.push('reopened by todo pending item');
+            reopened += 1;
+        }
+    }
+    for (const issue of byId.values()) {
+        if (issue.source !== 'todo.md')
+            continue;
+        if (activeIds.has(issue.id))
+            continue;
+        if (issue.status === 'done')
+            continue;
+        issue.status = 'done';
+        issue.updatedAt = timestamp;
+        issue.closedAt = timestamp;
+        issue.notes.push('auto-closed because todo item is no longer pending');
+        autoClosed += 1;
+    }
+    return {
+        state: {
+            version: 1,
+            updatedAt: timestamp,
+            issues: Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id)),
+        },
+        added,
+        reopened,
+        autoClosed,
+    };
+}
+export function setIssueStatus(prev, input, now) {
+    const issueId = normalizeId(input.id);
+    const timestamp = nowIso(now);
+    assertStatus(input.status);
+    const issue = prev.issues.find((item) => item.id === issueId);
+    if (!issue)
+        throw new Error(`issue not found: ${issueId}`);
+    assertAllowedTransition(issue.status, input.status);
+    issue.status = input.status;
+    issue.updatedAt = timestamp;
+    if (input.status === 'done')
+        issue.closedAt = timestamp;
+    if (input.status !== 'done')
+        issue.closedAt = undefined;
+    if (input.note && input.note.trim())
+        issue.notes.push(input.note.trim());
+    return {
+        version: 1,
+        updatedAt: timestamp,
+        issues: prev.issues,
+    };
+}
+export function createEmptyIssueState(now) {
+    return {
+        version: 1,
+        updatedAt: nowIso(now),
+        issues: [],
+    };
+}
+export async function loadIssueState(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.issues)) {
+            throw new Error('invalid issue state file');
+        }
+        return {
+            version: 1,
+            updatedAt: String(parsed.updatedAt ?? new Date(0).toISOString()),
+            issues: parsed.issues,
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return createEmptyIssueState();
+        }
+        throw error;
+    }
+}
+export async function saveIssueState(filePath, state) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf-8');
+}
+export function resolveIssueStatePath(input) {
+    return input ? path.resolve(process.cwd(), input) : path.resolve(process.cwd(), 'docs/issues/state.json');
+}
+export function resolveTodoPath(input) {
+    return input ? path.resolve(process.cwd(), input) : path.resolve(process.cwd(), 'todo.md');
+}

package/dist/runtime/claude/adapter.js

@@ -1,8 +1,9 @@
 // @ts-nocheck
-import { readFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { RUNTIME_CAPABILITIES } from '../shared/capabilities.js';
 import { normalizeTranscriptMessages, parseProjectIdFromTranscriptPath, pickUsage } from '../shared/normalize.js';
+const INFER_WINDOW_EPSILON_MS = 1200;
 function parseTimestamp(entry) {
     const raw = entry?.timestamp;
     const date = raw ? new Date(raw) : new Date();
@@ -17,6 +18,150 @@ function normalizeIsSidechain(entry) {
 function normalizeAgentId(entry) {
     return entry?.agentId ?? entry?.agent_id ?? entry?.message?.agentId ?? entry?.message?.agent_id;
 }
+function extractToolUses(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_use');
+}
+function extractToolResults(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isToolResultOnlyContent(content) {
+    return Array.isArray(content)
+        && content.length > 0
+        && content.every((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isPromptUserMessage(message) {
+    if (!message || message.role !== 'user' || message.isMeta)
+        return false;
+    const { content } = message;
+    if (typeof content === 'string')
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    if (isToolResultOnlyContent(content))
+        return false;
+    return content.length > 0;
+}
+function firstNonEmpty(values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+function findChildSessionHints(messages) {
+    const hasSidechainSignal = messages.some((m) => m?.isSidechain === true || String(m?.agentId ?? '').trim().length > 0);
+    if (!hasSidechainSignal)
+        return null;
+    const hasParentLink = messages.some((m) => String(m?.parentSessionId ?? m?.parent_session_id ?? '').trim().length > 0
+        || String(m?.parentTurnId ?? m?.parent_turn_id ?? '').trim().length > 0
+        || String(m?.parentToolCallId ?? m?.parent_tool_call_id ?? '').trim().length > 0);
+    if (hasParentLink)
+        return null;
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const childStartedAt = sorted[0]?.timestamp;
+    if (!childStartedAt)
+        return null;
+    return {
+        childStartedAt,
+        agentId: firstNonEmpty(messages.map((m) => m?.agentId)),
+    };
+}
+function extractTaskWindows(messages, sessionId) {
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const windows = [];
+    const byCallId = new Map();
+    let turnIndex = 0;
+    let currentTurnId = 'turn-1';
+    for (const msg of sorted) {
+        if (isPromptUserMessage(msg)) {
+            turnIndex += 1;
+            currentTurnId = `turn-${turnIndex}`;
+        }
+        if (msg.role === 'assistant') {
+            for (const tu of extractToolUses(msg.content)) {
+                const toolName = String(tu.name ?? '').trim();
+                if (toolName !== 'Task')
+                    continue;
+                const callId = String(tu.id ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = {
+                    parentSessionId: sessionId,
+                    parentTurnId: currentTurnId,
+                    parentToolCallId: callId,
+                    startedAtMs: msg.timestamp.getTime(),
+                    endedAtMs: msg.timestamp.getTime(),
+                };
+                windows.push(window);
+                byCallId.set(callId, window);
+            }
+        }
+        if (msg.role === 'user') {
+            for (const tr of extractToolResults(msg.content)) {
+                const callId = String(tr.tool_use_id ?? tr.toolUseId ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = byCallId.get(callId);
+                if (window) {
+                    window.endedAtMs = Math.max(window.endedAtMs, msg.timestamp.getTime());
+                }
+            }
+        }
+    }
+    return windows;
+}
+async function inferParentLinkFromSiblingSessions({ transcriptPath, messages }) {
+    const hints = findChildSessionHints(messages);
+    if (!hints)
+        return messages;
+    const currentSessionId = path.basename(transcriptPath, '.jsonl');
+    const dir = path.dirname(transcriptPath);
+    let entries = [];
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return messages;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const siblingSessionId = entry.name.slice(0, -'.jsonl'.length);
+        if (siblingSessionId === currentSessionId)
+            continue;
+        const siblingPath = path.join(dir, entry.name);
+        const siblingMessages = await readClaudeTranscript(siblingPath);
+        const windows = extractTaskWindows(siblingMessages, siblingSessionId);
+        for (const window of windows) {
+            const childAtMs = hints.childStartedAt.getTime();
+            const lower = window.startedAtMs - INFER_WINDOW_EPSILON_MS;
+            const upper = window.endedAtMs + INFER_WINDOW_EPSILON_MS;
+            if (childAtMs < lower || childAtMs > upper)
+                continue;
+            candidates.push({
+                ...window,
+                score: Math.abs(childAtMs - window.startedAtMs),
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return messages;
+    candidates.sort((a, b) => a.score - b.score);
+    const best = candidates[0];
+    return messages.map((msg) => ({
+        ...msg,
+        parentSessionId: best.parentSessionId,
+        parentTurnId: best.parentTurnId,
+        parentToolCallId: best.parentToolCallId,
+        parentLinkConfidence: 'inferred',
+    }));
+}
 async function readClaudeTranscript(transcriptPath) {
     const raw = await readFile(transcriptPath, 'utf-8');
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
@@ -29,6 +174,9 @@ async function readClaudeTranscript(transcriptPath) {
                 isMeta: entry.isMeta ?? false,
                 isSidechain: normalizeIsSidechain(entry),
                 agentId: normalizeAgentId(entry),
+                parentSessionId: entry?.parentSessionId ?? entry?.parent_session_id,
+                parentTurnId: entry?.parentTurnId ?? entry?.parent_turn_id,
+                parentToolCallId: entry?.parentToolCallId ?? entry?.parent_tool_call_id,
                 content: entry?.message?.content ?? entry.content ?? '',
                 model: entry?.message?.model ?? entry.model,
                 usage: pickUsage(entry?.message?.usage ?? entry?.usage ?? entry?.message_usage),
@@ -62,7 +210,8 @@ export const claudeCodeAdapter = {
     async collectEvents(context) {
         const transcriptPath = context.transcriptPath ??
             path.join(process.env.HOME || '', '.claude', 'projects', context.projectId, `${context.sessionId}.jsonl`);
-        const messages = await readClaudeTranscript(transcriptPath);
+        const loaded = await readClaudeTranscript(transcriptPath);
+        const messages = await inferParentLinkFromSiblingSessions({ transcriptPath, messages: loaded });
         return normalizeTranscriptMessages({
             runtime: 'claude-code',
             projectId: context.projectId,

package/dist/runtime/codex/adapter.js

@@ -77,6 +77,21 @@ function usageFromTotals(start, end) {
         total_tokens: total || input + output,
     });
 }
+function extractPtySessionId(output) {
+    const text = String(output ?? '');
+    const match = text.match(/session ID\s+(\d+)/i);
+    return match ? match[1] : undefined;
+}
+function extractWallTimeMs(output) {
+    const text = String(output ?? '');
+    const match = text.match(/Wall time:\s*([0-9]+(?:\.[0-9]+)?)\s*seconds?/i);
+    if (!match)
+        return undefined;
+    const seconds = Number(match[1]);
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        return undefined;
+    return Math.floor(seconds * 1000);
+}
 function createTurn(turnId, startedAt) {
     return {
         turnId,
@@ -194,6 +209,7 @@ async function readCodexSession(transcriptPath) {
     let sessionMeta = null;
     let callCounter = 0;
     const callIndex = new Map();
+    const ptyCallBySession = new Map();
     function finalizeCurrentTurn(at) {
         if (!currentTurn)
             return;
@@ -323,6 +339,11 @@ async function readCodexSession(transcriptPath) {
             const rawName = payload.name ?? payload.tool_name ?? payload.toolName;
             const rawInput = payload.type === 'custom_tool_call' ? payload.input : payload.arguments;
             const args = safeJsonParse(rawInput, typeof rawInput === 'string' ? { raw: rawInput } : {});
+            const ptySessionId = args.session_id != null ? String(args.session_id) : '';
+            if (String(rawName ?? '') === 'write_stdin' && ptySessionId && ptyCallBySession.has(ptySessionId)) {
+                callIndex.set(String(payload.call_id ?? payload.callId ?? `call-${callCounter}`), ptyCallBySession.get(ptySessionId));
+                continue;
+            }
             const normalized = normalizeToolCall(rawName, args, callCounter);
             const callId = String(payload.call_id ?? payload.callId ?? normalized.callId ?? `call-${callCounter}`);
             const call = {
@@ -341,8 +362,22 @@ async function readCodexSession(transcriptPath) {
             const callId = String(payload.call_id ?? payload.callId ?? '');
             const call = callIndex.get(callId);
             if (call) {
-                call.output = String(payload.output ?? '');
+                const output = String(payload.output ?? '');
+                if (output)
+                    call.output = output;
                 call.endedAt = isoAt;
+                const wallTimeMs = extractWallTimeMs(output);
+                if (wallTimeMs) {
+                    const derivedEndedAt = new Date(parseTimestamp(call.startedAt).getTime() + wallTimeMs).toISOString();
+                    if (parseTimestamp(derivedEndedAt).getTime() > parseTimestamp(call.endedAt).getTime()) {
+                        call.endedAt = derivedEndedAt;
+                    }
+                }
+                if (call.toolName === 'Bash') {
+                    const ptySessionId = extractPtySessionId(output);
+                    if (ptySessionId)
+                        ptyCallBySession.set(ptySessionId, call);
+                }
             }
             continue;
         }
@@ -398,11 +433,12 @@ function remapTurnIds(events, turns) {
 function attachCwdAttribute(events, cwd) {
     if (!cwd)
         return events;
+    const sanitizedCwd = deriveProjectIdFromCwd(cwd);
     return events.map((event) => ({
         ...event,
         attributes: {
             ...(event.attributes ?? {}),
-            'agentic.project.cwd': cwd,
+            'agentic.project.cwd': sanitizedCwd,
         },
     }));
 }

package/dist/runtime/openclaw/adapter.js

@@ -1,8 +1,9 @@
 // @ts-nocheck
-import { readFile, stat } from 'node:fs/promises';
+import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { RUNTIME_CAPABILITIES } from '../shared/capabilities.js';
 import { normalizeTranscriptMessages, parseProjectIdFromTranscriptPath, pickUsage } from '../shared/normalize.js';
+const INFER_WINDOW_EPSILON_MS = 1200;
 function parseTimestamp(entry) {
     const raw = entry?.timestamp ?? entry?.created_at ?? entry?.createdAt;
     const date = raw ? new Date(raw) : new Date();
@@ -140,6 +141,139 @@ function normalizeAgentId(entry) {
         ?? entry?.payload?.agentId
         ?? entry?.payload?.agent_id);
 }
+function extractToolUses(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_use');
+}
+function extractToolResults(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isToolResultOnlyContent(content) {
+    return Array.isArray(content)
+        && content.length > 0
+        && content.every((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isPromptUserMessage(message) {
+    if (!message || message.role !== 'user' || message.isMeta)
+        return false;
+    const { content } = message;
+    if (typeof content === 'string')
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    if (isToolResultOnlyContent(content))
+        return false;
+    return content.length > 0;
+}
+function findChildSessionHints(messages) {
+    const hasSidechainSignal = messages.some((m) => m?.isSidechain === true || String(m?.agentId ?? '').trim().length > 0);
+    if (!hasSidechainSignal)
+        return null;
+    const hasParentLink = messages.some((m) => String(m?.parentSessionId ?? m?.parent_session_id ?? '').trim().length > 0
+        || String(m?.parentTurnId ?? m?.parent_turn_id ?? '').trim().length > 0
+        || String(m?.parentToolCallId ?? m?.parent_tool_call_id ?? '').trim().length > 0);
+    if (hasParentLink)
+        return null;
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const childStartedAt = sorted[0]?.timestamp;
+    if (!childStartedAt)
+        return null;
+    return { childStartedAt };
+}
+function extractTaskWindows(messages, sessionId) {
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const windows = [];
+    const byCallId = new Map();
+    let turnIndex = 0;
+    let currentTurnId = 'turn-1';
+    for (const msg of sorted) {
+        if (isPromptUserMessage(msg)) {
+            turnIndex += 1;
+            currentTurnId = `turn-${turnIndex}`;
+        }
+        if (msg.role === 'assistant') {
+            for (const tu of extractToolUses(msg.content)) {
+                const toolName = String(tu.name ?? '').trim();
+                if (toolName !== 'Task')
+                    continue;
+                const callId = String(tu.id ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = {
+                    parentSessionId: sessionId,
+                    parentTurnId: currentTurnId,
+                    parentToolCallId: callId,
+                    startedAtMs: msg.timestamp.getTime(),
+                    endedAtMs: msg.timestamp.getTime(),
+                };
+                windows.push(window);
+                byCallId.set(callId, window);
+            }
+        }
+        if (msg.role === 'user') {
+            for (const tr of extractToolResults(msg.content)) {
+                const callId = String(tr.tool_use_id ?? tr.toolUseId ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = byCallId.get(callId);
+                if (window) {
+                    window.endedAtMs = Math.max(window.endedAtMs, msg.timestamp.getTime());
+                }
+            }
+        }
+    }
+    return windows;
+}
+async function inferParentLinkFromSiblingSessions({ transcriptPath, messages }) {
+    const hints = findChildSessionHints(messages);
+    if (!hints)
+        return messages;
+    const currentSessionId = path.basename(transcriptPath, '.jsonl');
+    const dir = path.dirname(transcriptPath);
+    let entries = [];
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return messages;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const siblingSessionId = entry.name.slice(0, -'.jsonl'.length);
+        if (siblingSessionId === currentSessionId)
+            continue;
+        const siblingPath = path.join(dir, entry.name);
+        const siblingMessages = await readOpenclawTranscript(siblingPath);
+        const windows = extractTaskWindows(siblingMessages, siblingSessionId);
+        for (const window of windows) {
+            const childAtMs = hints.childStartedAt.getTime();
+            const lower = window.startedAtMs - INFER_WINDOW_EPSILON_MS;
+            const upper = window.endedAtMs + INFER_WINDOW_EPSILON_MS;
+            if (childAtMs < lower || childAtMs > upper)
+                continue;
+            candidates.push({
+                ...window,
+                score: Math.abs(childAtMs - window.startedAtMs),
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return messages;
+    candidates.sort((a, b) => a.score - b.score);
+    const best = candidates[0];
+    return messages.map((msg) => ({
+        ...msg,
+        parentSessionId: best.parentSessionId,
+        parentTurnId: best.parentTurnId,
+        parentToolCallId: best.parentToolCallId,
+        parentLinkConfidence: 'inferred',
+    }));
+}
 async function readOpenclawTranscript(transcriptPath) {
     const raw = await readFile(transcriptPath, 'utf-8');
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
@@ -165,6 +299,9 @@ async function readOpenclawTranscript(transcriptPath) {
                 isMeta: entry?.isMeta ?? entry?.is_meta ?? false,
                 isSidechain: normalizeIsSidechain(entry),
                 agentId: normalizeAgentId(entry),
+                parentSessionId: entry?.parentSessionId ?? entry?.parent_session_id,
+                parentTurnId: entry?.parentTurnId ?? entry?.parent_turn_id,
+                parentToolCallId: entry?.parentToolCallId ?? entry?.parent_tool_call_id,
                 content: normalizeContent(entry),
                 model: normalizeModel(entry),
                 usage: normalizeUsage(entry),
@@ -231,7 +368,8 @@ export const openclawAdapter = {
     },
     async collectEvents(context) {
         const transcriptPath = await resolveTranscriptPath(context);
-        const messages = await readOpenclawTranscript(transcriptPath);
+        const loaded = await readOpenclawTranscript(transcriptPath);
+        const messages = await inferParentLinkFromSiblingSessions({ transcriptPath, messages: loaded });
         return normalizeTranscriptMessages({
             runtime: 'openclaw',
             projectId: context.projectId,

package/dist/runtime/shared/file-settle.d.ts

@@ -0,0 +1,19 @@
+type FileStat = {
+    mtimeMs: number;
+};
+type WaitForFileSettleOptions = {
+    filePath: string;
+    stableWindowMs?: number;
+    timeoutMs?: number;
+    pollMs?: number;
+    statFn?: (filePath: string) => Promise<FileStat>;
+    sleepFn?: (ms: number) => Promise<void>;
+    nowFn?: () => number;
+};
+type WaitForFileSettleResult = {
+    settled: boolean;
+    lastMtimeMs?: number;
+    waitedMs: number;
+};
+export declare function waitForFileMtimeToSettle(options: WaitForFileSettleOptions): Promise<WaitForFileSettleResult>;
+export {};

package/dist/runtime/shared/file-settle.js

@@ -0,0 +1,44 @@
+import { stat } from 'node:fs/promises';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function waitForFileMtimeToSettle(options) {
+    const stableWindowMs = options.stableWindowMs ?? 400;
+    const timeoutMs = options.timeoutMs ?? 2500;
+    const pollMs = options.pollMs ?? 100;
+    const statFn = options.statFn ?? (async (filePath) => stat(filePath));
+    const sleepFn = options.sleepFn ?? sleep;
+    const nowFn = options.nowFn ?? Date.now;
+    const startedAt = nowFn();
+    const deadline = startedAt + timeoutMs;
+    let lastMtimeMs;
+    let unchangedSinceMs;
+    while (nowFn() <= deadline) {
+        const current = await statFn(options.filePath);
+        const mtimeMs = Number(current.mtimeMs);
+        if (lastMtimeMs === mtimeMs) {
+            if (unchangedSinceMs === undefined)
+                unchangedSinceMs = nowFn();
+            if (nowFn() - unchangedSinceMs >= stableWindowMs) {
+                return {
+                    settled: true,
+                    lastMtimeMs: mtimeMs,
+                    waitedMs: nowFn() - startedAt,
+                };
+            }
+        }
+        else {
+            lastMtimeMs = mtimeMs;
+            unchangedSinceMs = undefined;
+        }
+        const remainingMs = deadline - nowFn();
+        if (remainingMs <= 0)
+            break;
+        await sleepFn(Math.min(pollMs, remainingMs));
+    }
+    return {
+        settled: false,
+        lastMtimeMs,
+        waitedMs: nowFn() - startedAt,
+    };
+}

package/dist/runtime/shared/normalize.js

@@ -210,6 +210,28 @@ function parseSlashCommand(text) {
         args: plain[2] ? plain[2].trim() : '',
     };
 }
+function parseBashCommandAttributes(commandLine) {
+    const raw = String(commandLine ?? '').trim();
+    if (!raw) {
+        return {
+            'agentic.command.name': '',
+            'agentic.command.args': '',
+            'agentic.command.pipe_count': 0,
+            'agentic.command.raw': '',
+        };
+    }
+    const segments = raw.split(/\|(?!\|)/);
+    const firstSegment = String(segments[0] ?? '').trim();
+    const tokens = firstSegment ? firstSegment.split(/\s+/) : [];
+    const name = String(tokens[0] ?? '').trim();
+    const args = tokens.length > 1 ? tokens.slice(1).join(' ') : '';
+    return {
+        'agentic.command.name': name,
+        'agentic.command.args': args,
+        'agentic.command.pipe_count': Math.max(segments.length - 1, 0),
+        'agentic.command.raw': raw,
+    };
+}
 function isMcpToolName(name) {
     const n = String(name || '').toLowerCase();
     return n === 'mcp' || n.startsWith('mcp__') || n.startsWith('mcp-');
@@ -252,6 +274,55 @@ function actorHeuristic(messages) {
         return { role: 'unknown', confidence: 0.6 };
     return { role: 'main', confidence: 0.95 };
 }
+function firstNonEmptyString(values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+function inferParentLinkAttributes(messages) {
+    const agentId = firstNonEmptyString(messages.map((m) => m?.agentId ?? m?.agent_id ?? m?.message?.agentId ?? m?.message?.agent_id));
+    const parentSessionId = firstNonEmptyString(messages.map((m) => m?.parentSessionId
+        ?? m?.parent_session_id
+        ?? m?.parent?.sessionId
+        ?? m?.parent?.session_id
+        ?? m?.session_meta?.parent_session_id
+        ?? m?.sessionMeta?.parentSessionId));
+    const parentTurnId = firstNonEmptyString(messages.map((m) => m?.parentTurnId
+        ?? m?.parent_turn_id
+        ?? m?.parent?.turnId
+        ?? m?.parent?.turn_id
+        ?? m?.session_meta?.parent_turn_id
+        ?? m?.sessionMeta?.parentTurnId));
+    const parentToolCallId = firstNonEmptyString(messages.map((m) => m?.parentToolCallId
+        ?? m?.parent_tool_call_id
+        ?? m?.parent?.toolCallId
+        ?? m?.parent?.tool_call_id
+        ?? m?.session_meta?.parent_tool_call_id
+        ?? m?.sessionMeta?.parentToolCallId));
+    const explicitConfidence = firstNonEmptyString(messages.map((m) => m?.parentLinkConfidence ?? m?.parent_link_confidence));
+    const attrs = {};
+    if (agentId)
+        attrs['agentic.agent_id'] = agentId;
+    if (parentSessionId)
+        attrs['agentic.parent.session_id'] = parentSessionId;
+    if (parentTurnId)
+        attrs['agentic.parent.turn_id'] = parentTurnId;
+    if (parentToolCallId)
+        attrs['agentic.parent.tool_call_id'] = parentToolCallId;
+    if (explicitConfidence) {
+        attrs['agentic.parent.link.confidence'] = explicitConfidence;
+    }
+    else if (parentSessionId || parentTurnId || parentToolCallId) {
+        attrs['agentic.parent.link.confidence'] = 'exact';
+    }
+    else if (agentId) {
+        attrs['agentic.parent.link.confidence'] = 'unknown';
+    }
+    return attrs;
+}
 function createTurn(messages, turnId, projectId, sessionId, runtime) {
     const user = messages.find(isPromptUserMessage) ?? messages.find((m) => m.role === 'user' && !m.isMeta) ?? messages[0];
     const assistantsRaw = messages.filter((m) => m.role === 'assistant');
@@ -283,6 +354,8 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
     }
     const usage = Object.keys(totalUsage).length ? totalUsage : undefined;
     const actor = actorHeuristic(messages);
+    const parentLinkAttrs = inferParentLinkAttributes(messages);
+    const sharedAttrs = { ...runtimeAttrs, ...parentLinkAttrs };
     const events = [
         {
             runtime,
@@ -299,7 +372,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                 'agentic.event.category': 'turn',
                 'langfuse.observation.type': 'agent',
                 'gen_ai.operation.name': 'invoke_agent',
-                ...runtimeAttrs,
+                ...sharedAttrs,
                 ...modelAttributes(latestModel),
                 'agentic.actor.role': actor.role,
                 'agentic.actor.role_confidence': actor.confidence,
@@ -348,7 +421,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                 attributes: {
                     'agentic.event.category': isMcp ? 'mcp' : 'agent_command',
                     'langfuse.observation.type': isMcp ? 'tool' : 'event',
-                    ...runtimeAttrs,
+                    ...sharedAttrs,
                     'agentic.command.name': slash.name,
                     'agentic.command.args': slash.args,
                     'gen_ai.operation.name': isMcp ? 'execute_tool' : 'invoke_agent',
@@ -377,7 +450,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                 attributes: {
                     'agentic.event.category': 'reasoning',
                     'langfuse.observation.type': 'span',
-                    ...runtimeAttrs,
+                    ...sharedAttrs,
                     'gen_ai.operation.name': 'invoke_agent',
                     ...modelAttributes(assistant.model),
                 },
@@ -408,8 +481,9 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                     attributes: {
                         'agentic.event.category': 'shell_command',
                         'langfuse.observation.type': 'tool',
-                        ...runtimeAttrs,
+                        ...sharedAttrs,
                         'process.command_line': commandLine,
+                        ...parseBashCommandAttributes(commandLine),
                         'gen_ai.tool.name': 'Bash',
                         'gen_ai.tool.call.id': toolId,
                         'gen_ai.operation.name': 'execute_tool',
@@ -435,7 +509,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                     attributes: {
                         'agentic.event.category': 'mcp',
                         'langfuse.observation.type': 'tool',
-                        ...runtimeAttrs,
+                        ...sharedAttrs,
                         'gen_ai.tool.name': toolName,
                         'mcp.request.id': toolId,
                         'gen_ai.operation.name': 'execute_tool',
@@ -461,7 +535,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                     attributes: {
                         'agentic.event.category': 'agent_task',
                         'langfuse.observation.type': 'agent',
-                        ...runtimeAttrs,
+                        ...sharedAttrs,
                         'gen_ai.tool.name': 'Task',
                         'gen_ai.tool.call.id': toolId,
                         'gen_ai.operation.name': 'invoke_agent',
@@ -486,7 +560,7 @@ function createTurn(messages, turnId, projectId, sessionId, runtime) {
                     attributes: {
                         'agentic.event.category': 'tool',
                         'langfuse.observation.type': 'tool',
-                        ...runtimeAttrs,
+                        ...sharedAttrs,
                         'gen_ai.tool.name': toolName,
                         'gen_ai.tool.call.id': toolId,
                         'gen_ai.operation.name': 'execute_tool',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bububuger/spanory",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Spanory CLI for cross-runtime agent observability",
   "license": "MIT",
   "type": "module",