@amsterdamdatalabs/traces 0.1.0 → 0.1.3

package/README.md

@@ -13,7 +13,7 @@
 - **Span attribute constants** — `enact.*` and `llm.*` extension attributes on top of the OpenInference semantic conventions
 - **Emit** — a zero-dependency `emitEvent()` that writes NDJSON to the watchdog dir and publishes to Apache Iggy in parallel
 
-Used by `enact-gateway`, `enact-factory`, `enact-memory`, `enact-agent`, and `enact-watchdog`.
+Used by `enact-gateway`, `enact-factory`, `enact-wiki`, `enact-agent`, and `enact-watchdog`.
 
 ## Installation
 

package/dist/conventions/enact-extensions.d.ts

@@ -104,7 +104,7 @@ export declare const ENACT_ITEMS_PROCESSED: "enact.items_processed";
 export declare const ENACT_QUERY_HASH: "enact.query_hash";
 export declare const ENACT_RESULTS_COUNT: "enact.results_count";
 export declare const ENACT_SLUG: "enact.slug";
-export declare const ENACT_MEMORY_TYPE: "enact.memory_type";
+export declare const ENACT_WIKI_TYPE: "enact.wiki_type";
 export declare const ENACT_IMPORTANCE: "enact.importance";
 export declare const ENACT_SOURCE: "enact.source";
 export declare const ENACT_TOKENS_USED: "enact.tokens_used";

package/dist/conventions/enact-extensions.js

@@ -122,7 +122,7 @@ export const ENACT_ITEMS_PROCESSED = 'enact.items_processed';
 export const ENACT_QUERY_HASH = 'enact.query_hash';
 export const ENACT_RESULTS_COUNT = 'enact.results_count';
 export const ENACT_SLUG = 'enact.slug';
-export const ENACT_MEMORY_TYPE = 'enact.memory_type';
+export const ENACT_WIKI_TYPE = 'enact.wiki_type';
 export const ENACT_IMPORTANCE = 'enact.importance';
 // enact.* extension attributes — agent
 export const ENACT_SOURCE = 'enact.source';

package/dist/emit/emit.d.ts

@@ -3,9 +3,13 @@ export type { EnactRawV1Event };
 export interface EmitOptions {
     /** NDJSON filename within the watchdog dir, e.g. 'factory-events.ndjson' */
     ndjsonFile: string;
-    /** Override ENACT_WATCHDOG_DIR env var */
+    /** Explicit override for watchdog dir */
     watchdogDir?: string;
-    /** Override IGGY_HTTP_URL env var */
+    /** Explicit override for Iggy HTTP base URL */
     iggyUrl?: string;
+    /** Explicit override for the workspace-scoped Iggy stream */
+    iggyStream?: string;
+    /** Explicit override for the logical Iggy topic */
+    iggyTopic?: string;
 }
 export declare function emitEvent(event: EnactRawV1Event, opts: EmitOptions): Promise<void>;

package/dist/emit/emit.js

@@ -1,29 +1,27 @@
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-const DEFAULT_IGGY_URL = 'http://127.0.0.1:43214';
+import { rootIggyHttpUrl, rootIggyPassword, rootIggyTopic, rootScopedIggyStream, rootIggyUsername, rootWatchdogDir, } from './root-config.js';
 export async function emitEvent(event, opts) {
-    const watchdogDir = opts.watchdogDir ?? process.env.ENACT_WATCHDOG_DIR ?? '.enact/watchdog';
+    const watchdogDir = opts.watchdogDir ??
+        rootWatchdogDir();
     mkdirSync(watchdogDir, { recursive: true });
     const ndjsonPath = join(watchdogDir, opts.ndjsonFile);
-    const rawIggyUrl = opts.iggyUrl ?? process.env.IGGY_HTTP_URL;
-    const iggyUrl = !rawIggyUrl || rawIggyUrl === 'undefined' || rawIggyUrl === 'null'
-        ? DEFAULT_IGGY_URL
-        : rawIggyUrl;
+    const iggyUrl = opts.iggyUrl ?? rootIggyHttpUrl();
+    const iggyStream = opts.iggyStream ?? rootScopedIggyStream();
+    const iggyTopic = opts.iggyTopic ?? rootIggyTopic();
     const results = await Promise.allSettled([
         Promise.resolve().then(() => {
             appendFileSync(ndjsonPath, `${JSON.stringify(event)}\n`, 'utf8');
         }),
-        publishToIggy(iggyUrl, event),
+        publishToIggy(iggyUrl, iggyStream, iggyTopic, event),
     ]);
     for (const result of results) {
         if (result.status === 'rejected') {
-            if (process.env.ENACT_OBSERVABILITY_DEBUG) {
-                console.error(`[enact-traces] emit error: ${String(result.reason)}`);
-            }
+            console.error(`[enact-traces] emit error: ${String(result.reason)}`);
         }
     }
 }
-async function publishToIggy(baseUrl, event) {
+async function publishToIggy(baseUrl, stream, topic, event) {
     const authHeader = await resolveIggyAuthHeader(baseUrl);
     const payload = {
         partitioning: { kind: 'balanced', value: '' },
@@ -35,7 +33,7 @@ async function publishToIggy(baseUrl, event) {
         ],
     };
     try {
-        const response = await fetch(`${baseUrl}/streams/enact-telemetry/topics/worker_telemetry/messages`, {
+        const response = await fetch(`${baseUrl}/streams/${stream}/topics/${topic}/messages`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -61,8 +59,8 @@ async function resolveIggyAuthHeader(baseUrl) {
     if (rawToken?.trim()) {
         return `Bearer ${rawToken.trim()}`;
     }
-    const username = process.env.IGGY_HTTP_USERNAME ?? process.env.IGGY_ROOT_USERNAME ?? 'iggy';
-    const password = process.env.IGGY_HTTP_PASSWORD ?? process.env.IGGY_ROOT_PASSWORD ?? 'iggy';
+    const username = rootIggyUsername();
+    const password = rootIggyPassword();
     const response = await fetch(`${baseUrl}/users/login`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },

package/dist/emit/root-config.d.ts

@@ -0,0 +1,60 @@
+interface RootPathsCfg {
+    use_global?: boolean;
+    project?: string;
+    global?: string;
+}
+interface RootWatchdogCfg {
+    iggy_http_url?: string;
+    iggy_username?: string;
+    iggy_password?: string;
+    topic?: string;
+}
+interface RootIggyCfg {
+    host?: string;
+    port?: number;
+    stream?: string;
+    topic?: string;
+}
+interface RootConfig {
+    paths?: RootPathsCfg;
+    agent?: {
+        watchdog_dir?: string;
+    };
+    watchdog?: RootWatchdogCfg;
+    iggy?: RootIggyCfg;
+}
+export interface ResolvedConfigContext {
+    merged: RootConfig;
+    globalConfig: RootConfig | null;
+    workspaceConfig: RootConfig | null;
+    globalConfigPath: string | null;
+    globalConfigDir: string;
+    workspaceConfigPath: string | null;
+    workspaceRoot: string | null;
+}
+export declare function resetResolvedConfigCacheForTests(): void;
+export declare function readRootConfig(): RootConfig;
+export declare function resolveConfigContext(): ResolvedConfigContext;
+/**
+ * Resolve a per-key string value, honoring the provenance rule: relative paths
+ * resolve against the directory of the config.toml that declared the value.
+ * Workspace declarations win over global; global declarations resolve against
+ * `~/.enact`.
+ */
+export declare function resolveDeclaredPath(workspaceValue: string | undefined, globalValue: string | undefined, context?: ResolvedConfigContext): string | null;
+export declare function expandPathFromBase(value: string, sourceDir: string): string;
+/**
+ * Resolve the runtime base dir (the `[paths]`-selected root). Each individual
+ * field in `[paths]` honors per-key provenance, so a workspace-set `use_global`
+ * combined with a global-set `global` is supported correctly.
+ */
+export declare function resolveRuntimeBaseDir(context?: ResolvedConfigContext): string;
+export declare function rootWatchdogDir(): string;
+export declare function rootIggyHttpUrl(): string;
+export declare function rootIggyUsername(): string;
+export declare function rootIggyPassword(): string;
+export declare function rootIggyStream(): string;
+export declare function rootIggyTopic(): string;
+export declare function deriveWorkspaceId(root?: string): string;
+export declare function rootScopedIggyStream(): string;
+export {};

package/dist/emit/root-config.js

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+const DEFAULT_PROJECT = '.enact';
+const DEFAULT_GLOBAL = '~/.enact';
+let cachedContext = null;
+export function resetResolvedConfigCacheForTests() {
+    cachedContext = null;
+}
+export function readRootConfig() {
+    return resolveConfigContext().merged;
+}
+export function resolveConfigContext() {
+    if (cachedContext)
+        return cachedContext;
+    const filename = configFileName();
+    const globalConfigDir = join(homedir(), '.enact');
+    const globalConfigPath = join(globalConfigDir, filename);
+    const workspaceConfigPath = findWorkspaceConfigToml(filename);
+    const globalConfig = readConfigIfExists(globalConfigPath);
+    const workspaceConfig = workspaceConfigPath ? readConfigIfExists(workspaceConfigPath) : null;
+    if (!globalConfig && !workspaceConfig) {
+        throw new Error('Missing required root config.toml / config.prd.toml');
+    }
+    const merged = mergeRootConfig(globalConfig ?? {}, workspaceConfig ?? {});
+    cachedContext = {
+        merged,
+        globalConfig,
+        workspaceConfig,
+        globalConfigPath: globalConfig ? globalConfigPath : null,
+        globalConfigDir,
+        workspaceConfigPath,
+        workspaceRoot: workspaceConfigPath ? dirname(workspaceConfigPath) : null,
+    };
+    return cachedContext;
+}
+/**
+ * Resolve a per-key string value, honoring the provenance rule: relative paths
+ * resolve against the directory of the config.toml that declared the value.
+ * Workspace declarations win over global; global declarations resolve against
+ * `~/.enact`.
+ */
+export function resolveDeclaredPath(workspaceValue, globalValue, context = resolveConfigContext()) {
+    const declared = pickDeclared(workspaceValue, globalValue, context);
+    if (!declared)
+        return null;
+    return expandPathFromBase(declared.value, declared.sourceDir);
+}
+export function expandPathFromBase(value, sourceDir) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed === '~')
+        return homedir();
+    if (trimmed.startsWith('~/'))
+        return join(homedir(), trimmed.slice(2));
+    if (isAbsolute(trimmed))
+        return trimmed;
+    return resolve(sourceDir, trimmed);
+}
+/**
+ * Resolve the runtime base dir (the `[paths]`-selected root). Each individual
+ * field in `[paths]` honors per-key provenance, so a workspace-set `use_global`
+ * combined with a global-set `global` is supported correctly.
+ */
+export function resolveRuntimeBaseDir(context = resolveConfigContext()) {
+    const useGlobal = context.workspaceConfig?.paths?.use_global ??
+        context.globalConfig?.paths?.use_global ??
+        false;
+    if (useGlobal) {
+        const resolved = resolveDeclaredPath(context.workspaceConfig?.paths?.global, context.globalConfig?.paths?.global, context);
+        return resolved ?? expandPathFromBase(DEFAULT_GLOBAL, context.globalConfigDir);
+    }
+    const resolved = resolveDeclaredPath(context.workspaceConfig?.paths?.project, context.globalConfig?.paths?.project, context);
+    if (resolved)
+        return resolved;
+    // Default: project relative to the *workspace* config dir; fall back to home if absent.
+    const base = context.workspaceRoot ?? context.globalConfigDir;
+    return expandPathFromBase(DEFAULT_PROJECT, base);
+}
+export function rootWatchdogDir() {
+    const context = resolveConfigContext();
+    const declared = resolveDeclaredPath(context.workspaceConfig?.agent?.watchdog_dir, context.globalConfig?.agent?.watchdog_dir, context);
+    if (declared)
+        return declared;
+    return join(resolveRuntimeBaseDir(context), 'watchdog');
+}
+export function rootIggyHttpUrl() {
+    const config = readRootConfig();
+    if (config?.watchdog?.iggy_http_url)
+        return config.watchdog.iggy_http_url;
+    if (!config?.iggy?.host || typeof config.iggy.port !== 'number') {
+        throw new Error('Missing required iggy.host/iggy.port in root config for enact-traces');
+    }
+    return `http://${config.iggy.host}:${config.iggy.port}`;
+}
+export function rootIggyUsername() {
+    const username = readRootConfig()?.watchdog?.iggy_username;
+    if (!username) {
+        throw new Error('Missing required watchdog.iggy_username in root config for enact-traces');
+    }
+    return username;
+}
+export function rootIggyPassword() {
+    const password = readRootConfig()?.watchdog?.iggy_password;
+    if (!password) {
+        throw new Error('Missing required watchdog.iggy_password in root config for enact-traces');
+    }
+    return password;
+}
+export function rootIggyStream() {
+    const config = readRootConfig();
+    const stream = config.iggy?.stream;
+    if (!stream) {
+        throw new Error('Missing required iggy.stream in root config for enact-traces');
+    }
+    return stream;
+}
+export function rootIggyTopic() {
+    const config = readRootConfig();
+    const topic = config.iggy?.topic;
+    if (!topic) {
+        throw new Error('Missing required iggy.topic in root config for enact-traces');
+    }
+    return topic;
+}
+export function deriveWorkspaceId(root = resolveConfigContext().workspaceRoot ?? process.cwd()) {
+    const resolvedRoot = resolve(root);
+    const name = basename(resolvedRoot) || 'workspace';
+    const hash6 = createHash('sha256').update(resolvedRoot).digest('hex').slice(0, 6);
+    return `${name}-${hash6}`;
+}
+export function rootScopedIggyStream() {
+    return `ws_${deriveWorkspaceId()}_${rootIggyStream()}`;
+}
+function pickDeclared(workspaceValue, globalValue, context) {
+    if (typeof workspaceValue === 'string' && workspaceValue.trim() && context.workspaceRoot) {
+        return { value: workspaceValue, sourceDir: context.workspaceRoot };
+    }
+    if (typeof globalValue === 'string' && globalValue.trim() && context.globalConfigPath) {
+        return { value: globalValue, sourceDir: context.globalConfigDir };
+    }
+    return null;
+}
+function configFileName() {
+    return process.env.NODE_ENV === 'production' ? 'config.prd.toml' : 'config.toml';
+}
+function findWorkspaceConfigToml(filename) {
+    const home = resolve(homedir());
+    let dir = process.cwd();
+    while (true) {
+        const candidate = join(dir, filename);
+        if (existsSync(candidate))
+            return candidate;
+        if (resolve(dir) === home)
+            return null;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function readConfigIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseRootConfig(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Invalid root config.toml / config.prd.toml for enact-traces at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function mergeRootConfig(base, overlay) {
+    return {
+        ...base,
+        ...overlay,
+        paths: { ...(base.paths ?? {}), ...(overlay.paths ?? {}) },
+        agent: { ...(base.agent ?? {}), ...(overlay.agent ?? {}) },
+        watchdog: { ...(base.watchdog ?? {}), ...(overlay.watchdog ?? {}) },
+        iggy: { ...(base.iggy ?? {}), ...(overlay.iggy ?? {}) },
+    };
+}
+function parseRootConfig(raw) {
+    const config = {};
+    let section = '';
+    for (const originalLine of raw.split('\n')) {
+        const line = originalLine.replace(/#.*$/, '').trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1] ?? '';
+            continue;
+        }
+        const kvMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*(.+)$/);
+        if (!kvMatch)
+            continue;
+        const key = kvMatch[1];
+        const value = parseValue(kvMatch[2]);
+        assignValue(config, section, key, value);
+    }
+    return config;
+}
+function parseValue(raw) {
+    const value = raw.trim();
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^\d+$/.test(value))
+        return Number(value);
+    if (value.startsWith('[') && value.endsWith(']')) {
+        return value
+            .slice(1, -1)
+            .split(',')
+            .map((part) => stripQuotes(part.trim()))
+            .filter(Boolean);
+    }
+    return stripQuotes(value);
+}
+function stripQuotes(value) {
+    return value.replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1');
+}
+function assignValue(config, section, key, value) {
+    if (section === 'paths') {
+        config.paths ??= {};
+        config.paths[key] = value;
+    }
+    else if (section === 'agent') {
+        config.agent ??= {};
+        config.agent[key] = value;
+    }
+    else if (section === 'watchdog') {
+        config.watchdog ??= {};
+        config.watchdog[key] = value;
+    }
+    else if (section === 'iggy') {
+        config.iggy ??= {};
+        config.iggy[key] = value;
+    }
+}

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './conventions/index.js';
 export * from './types/index.js';
 export * from './payloads/index.js';
 export * from './emit/emit.js';
+export * from './emit/root-config.js';

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './conventions/index.js';
 export * from './types/index.js';
 export * from './payloads/index.js';
 export * from './emit/emit.js';
+export * from './emit/root-config.js';

package/dist/payloads/agent-lifecycle.d.ts

@@ -4,11 +4,38 @@ export interface AgentThreadStartedPayload {
     'session.id'?: string;
     [key: string]: unknown;
 }
-export interface AgentTurnPayload {
+export interface AgentTurnStartPayload {
     'openinference.span.kind': 'AGENT';
-    'enact.source'?: string;
-    turn_index?: number;
-    [key: string]: unknown;
+    stage: 'turn.start';
+    turn_id: string;
+    model?: string;
+    cwd?: string;
+    'agent.name'?: string;
+    'input.value'?: string;
+    'llm.invocation_parameters'?: string;
+    'enact.collaboration_mode'?: string;
+    metadata?: string;
+}
+export interface AgentTurnEndPayload {
+    'openinference.span.kind': 'AGENT';
+    stage: 'turn.end';
+    turn_id: string;
+    duration_ms: number;
+    status: string;
+    'output.value'?: string;
+    'llm.token_count.prompt'?: number;
+    'llm.token_count.completion'?: number;
+    'llm.token_count.total'?: number;
+    'enact.success'?: boolean;
+    'enact.duration_ms'?: number;
+    /** The user's original prompt text — enables full replay of the turn. */
+    'input.value'?: string;
+    /** Canonical OpenInference ordered input messages (system prompt at index 0 if present, user prompt follows). */
+    'llm.input_messages.0.message.role'?: string;
+    'llm.input_messages.0.message.content'?: string;
+    'llm.input_messages.1.message.role'?: string;
+    'llm.input_messages.1.message.content'?: string;
+    metadata?: string;
 }
 export interface AgentTokenUsagePayload {
     'openinference.span.kind': 'CHAIN';
@@ -24,4 +51,124 @@ export interface AgentErrorPayload {
     'enact.message'?: string;
     error_type?: string;
 }
-export type AgentLifecyclePayload = AgentThreadStartedPayload | AgentTurnPayload | AgentTokenUsagePayload | AgentErrorPayload;
+export interface AgentHookStartedPayload {
+    'openinference.span.kind': 'TOOL';
+    stage: 'hook.started';
+    turn_id?: string;
+    hook_id: string;
+    event_name: string;
+    handler_type: string;
+    scope: string;
+    'tool.name'?: string;
+    'enact.hook_event'?: string;
+    'enact.preset'?: string;
+    'input.value'?: string;
+    metadata?: string;
+}
+export interface AgentHookCompletedPayload {
+    'openinference.span.kind': 'TOOL';
+    stage: 'hook.completed';
+    turn_id?: string;
+    hook_id: string;
+    event_name: string;
+    status: string;
+    duration_ms?: number;
+    'tool.name'?: string;
+    'enact.hook_event'?: string;
+    'enact.outcome'?: string;
+    'enact.success'?: boolean;
+    'enact.duration_ms'?: number;
+    'output.value'?: string;
+    'exception.message'?: string;
+    /** The hook's trigger input (e.g. user prompt text for UserPromptSubmit hooks). */
+    'input.value'?: string;
+    metadata?: string;
+}
+export interface AgentToolDispatchedPayload {
+    'openinference.span.kind': 'TOOL';
+    stage: 'tool.dispatched';
+    turn_id: string;
+    tool_call_id: string;
+    tool_name: string;
+    tool_namespace?: string | null;
+    /** OpenInference canonical tool identifier — equals tool_call_id. */
+    'tool.id'?: string;
+    'tool.parameters'?: string;
+    /** OpenInference tool description from registry spec. */
+    'tool.description'?: string;
+    /** OpenInference tool JSON schema from registry spec. */
+    'tool.json_schema'?: string;
+    'input.value'?: string;
+    metadata?: string;
+}
+export interface AgentToolCompletedPayload {
+    'openinference.span.kind': 'TOOL';
+    stage: 'tool.completed';
+    turn_id: string;
+    tool_call_id: string;
+    tool_name: string;
+    tool_namespace?: string | null;
+    /** OpenInference canonical tool identifier — equals tool_call_id. */
+    'tool.id'?: string;
+    'tool.output'?: string;
+    'output.value'?: string;
+    duration_ms: number;
+    'enact.duration_ms'?: number;
+    success: boolean;
+    'enact.success'?: boolean;
+    'exception.message'?: string;
+    /** The serialized tool parameters — enables full replay of the tool call. */
+    'tool.parameters'?: string;
+    /** OpenInference tool description from registry spec. */
+    'tool.description'?: string;
+    /** OpenInference tool JSON schema from registry spec. */
+    'tool.json_schema'?: string;
+    /** Wire alias of tool.parameters projected by build_envelope. */
+    'input.value'?: string;
+    metadata?: string;
+}
+export interface AgentSkillActivatedPayload {
+    'openinference.span.kind': 'CHAIN';
+    stage: 'skill.activated';
+    skill_id: string;
+    skill_name: string;
+    activator: string;
+    scope: string;
+    'tool.name'?: string;
+    'enact.scope'?: string;
+    'input.value'?: string;
+    metadata?: string;
+}
+export interface AgentSkillCompletedPayload {
+    'openinference.span.kind': 'CHAIN';
+    stage: 'skill.completed';
+    skill_id: string;
+    skill_name: string;
+    scope: string;
+    duration_ms: number;
+    success: boolean;
+    'tool.name'?: string;
+    'enact.scope'?: string;
+    'enact.duration_ms'?: number;
+    'enact.success'?: boolean;
+    'output.value'?: string;
+    'exception.message'?: string;
+    'exception.type'?: string;
+    metadata?: string;
+}
+export interface AgentPluginLoadedPayload {
+    'openinference.span.kind': 'CHAIN';
+    stage: 'plugin.loaded';
+    plugin_id: string;
+    plugin_name: string;
+    source: string;
+    version?: string | null;
+    success: boolean;
+    'tool.name'?: string;
+    'enact.success'?: boolean;
+    'exception.message'?: string;
+    'exception.type'?: string;
+    'exception.stacktrace'?: string;
+    metadata?: string;
+}
+export type AgentLifecyclePayload = AgentThreadStartedPayload | AgentTurnStartPayload | AgentTurnEndPayload | AgentTokenUsagePayload | AgentErrorPayload | AgentHookStartedPayload | AgentHookCompletedPayload | AgentToolDispatchedPayload | AgentToolCompletedPayload | AgentSkillActivatedPayload | AgentSkillCompletedPayload | AgentPluginLoadedPayload;

package/dist/payloads/evolve-events.d.ts

@@ -0,0 +1,83 @@
+export interface EvolveTranscriptMessageRecordedPayload {
+    'openinference.span.kind': 'AGENT';
+    role: string;
+    content: string;
+    timestamp?: string;
+}
+export interface EvolveTranscriptPromptRecordedPayload {
+    'openinference.span.kind': 'CHAIN';
+    prompt_kind: string;
+    source?: string;
+    content: string;
+    timestamp?: string;
+}
+export interface EvolveTranscriptToolRecordedPayload {
+    'openinference.span.kind': 'TOOL';
+    tool_id?: string;
+    'tool.name': string;
+    'tool.parameters'?: string;
+    'tool.output'?: string;
+    'enact.success'?: boolean;
+    status: string;
+    timestamp?: string;
+}
+export interface EvolveTranscriptHookRecordedPayload {
+    'openinference.span.kind': 'CHAIN';
+    hook_name: string;
+    hook_event: string;
+    status: string;
+    command?: string;
+    content?: string;
+    timestamp?: string;
+}
+export interface EvolveTranscriptSkillRecordedPayload {
+    'openinference.span.kind': 'CHAIN';
+    skill_name: string;
+    status: string;
+    description?: string;
+    content?: string;
+    timestamp?: string;
+}
+export interface EvolveTranscriptContextRecordedPayload {
+    'openinference.span.kind': 'CHAIN';
+    context_kind: string;
+    label: string;
+    content: string;
+    timestamp?: string;
+}
+export interface EvolveEvidenceNormalizedPayload {
+    'openinference.span.kind': 'CHAIN';
+    evidence_id: string;
+    surface: string;
+    files_touched: number;
+    failure_count: number;
+    prompt_count: number;
+    hook_count: number;
+    skill_count: number;
+    context_count: number;
+    tool_summary_count?: number;
+    hook_summary_count?: number;
+    trace_event_summary_count?: number;
+}
+export interface EvolveMetricComputedPayload {
+    'openinference.span.kind': 'CHAIN';
+    read_edit_ratio?: number | null;
+    research_mutation_ratio?: number | null;
+    edit_without_read_count?: number;
+    repeated_edit_open_loops?: number;
+    tool_failure_retry_loops?: number;
+    watchdog_failure_count?: number;
+    watchdog_recovery_count?: number;
+    user_correction_markers?: number;
+    cost_latency_records?: number;
+    retrieval_miss_markers?: number;
+    task_closeout_status?: string;
+}
+export interface EvolveCandidateProposedPayload {
+    'openinference.span.kind': 'CHAIN';
+    candidate_id: string;
+    target_family: string;
+    policy_route: string;
+    source_signals: string[];
+}
+export type EvolveEventPayload = EvolveTranscriptMessageRecordedPayload | EvolveTranscriptPromptRecordedPayload | EvolveTranscriptToolRecordedPayload | EvolveTranscriptHookRecordedPayload | EvolveTranscriptSkillRecordedPayload | EvolveTranscriptContextRecordedPayload | EvolveEvidenceNormalizedPayload | EvolveMetricComputedPayload | EvolveCandidateProposedPayload;

package/dist/payloads/evolve-events.js

@@ -0,0 +1 @@
+export {};

package/dist/payloads/index.d.ts

@@ -7,3 +7,4 @@ export * from './cache-hit.js';
 export * from './agent-lifecycle.js';
 export * from './proc-tap.js';
 export * from './hand.js';
+export * from './evolve-events.js';

package/dist/payloads/index.js

@@ -7,3 +7,4 @@ export * from './cache-hit.js';
 export * from './agent-lifecycle.js';
 export * from './proc-tap.js';
 export * from './hand.js';
+export * from './evolve-events.js';

package/dist/payloads/llm-call.js

@@ -65,11 +65,13 @@ export function expandTools(tools) {
 export function flattenPayload(payload) {
     const { _input_messages, _output_messages, _tools, ...rest } = payload;
     const flat = { ...rest };
-    if (_input_messages?.length) {
-        Object.assign(flat, expandMessages('llm.input_messages', _input_messages));
-        const lastUser = [..._input_messages].reverse().find((m) => m['message.role'] === 'user');
-        if (lastUser?.['message.content'])
-            flat['input.value'] = lastUser['message.content'];
+    if (_input_messages) {
+        if (_input_messages.length) {
+            Object.assign(flat, expandMessages('llm.input_messages', _input_messages));
+            const lastUser = [..._input_messages].reverse().find((m) => m['message.role'] === 'user');
+            if (lastUser?.['message.content'])
+                flat['input.value'] = lastUser['message.content'];
+        }
     }
     if (_output_messages?.length) {
         Object.assign(flat, expandMessages('llm.output_messages', _output_messages));

package/dist/payloads/memory-search.d.ts

@@ -1,21 +1,22 @@
 export interface MemorySearchPayload {
     'openinference.span.kind': 'RETRIEVER';
     'input.value'?: string;
-    'retrieval.documents'?: unknown[];
     'enact.query_hash'?: string;
     'enact.results_count'?: number;
     'enact.duration_ms'?: number;
+    [k: `retrieval.documents.${number}.document.${'id' | 'content' | 'score' | 'metadata'}`]: string | number | undefined;
 }
 export interface MemoryWritePayload {
     'openinference.span.kind': 'CHAIN';
     'enact.slug'?: string;
-    'enact.memory_type'?: string;
+    'enact.wiki_type'?: string;
     'enact.importance'?: number;
     'input.value'?: string;
+    'output.value'?: string;
 }
 export interface MemoryLifecyclePayload {
     'openinference.span.kind': 'CHAIN';
     lifecycle_event: string;
-    'enact.memory_type'?: string;
+    'enact.wiki_type'?: string;
     [key: string]: unknown;
 }

package/dist/types/envelope.d.ts

@@ -1,5 +1,5 @@
-import type { LlmCallPayload, HookFiredPayload, ToolCallPayload, MemorySearchPayload, MemoryWritePayload, CacheHitPayload, AgentLifecyclePayload } from '../payloads/index.js';
-export type EventPayload = LlmCallPayload | HookFiredPayload | ToolCallPayload | MemorySearchPayload | MemoryWritePayload | CacheHitPayload | AgentLifecyclePayload | Record<string, unknown>;
+import type { LlmCallPayload, HookFiredPayload, ToolCallPayload, MemorySearchPayload, MemoryWritePayload, CacheHitPayload, AgentLifecyclePayload, EvolveEventPayload } from '../payloads/index.js';
+export type EventPayload = LlmCallPayload | HookFiredPayload | ToolCallPayload | MemorySearchPayload | MemoryWritePayload | CacheHitPayload | AgentLifecyclePayload | EvolveEventPayload | Record<string, unknown>;
 export interface EnactRawV1Event {
     schema_version: 'enact.raw.v1';
     source: string;
@@ -11,5 +11,19 @@ export interface EnactRawV1Event {
     pid?: number;
     parent_pid?: number;
     correlation_id?: string;
+    trace_id?: string;
+    parent_span_id?: string;
     payload: EventPayload;
 }
+/**
+ * Subset of payload fields projected by build_envelope that are always
+ * present at the payload level for OpenInference consumers (not the envelope root).
+ */
+export interface EnactPayloadEnrichments {
+    /** OpenInference canonical session identifier. */
+    'session.id'?: string;
+    /** OpenInference canonical user identifier — projected from EmitContext.user_id. */
+    'user.id'?: string;
+    /** OpenInference span classification. */
+    'openinference.span.kind'?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amsterdamdatalabs/traces",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Shared OpenInference tracing types and emit for enact-os packages",
   "license": "UNLICENSED",
   "type": "module",
@@ -34,14 +34,18 @@
   "scripts": {
     "build": "rm -rf dist && tsc",
     "dev": "tsc --watch",
-    "lint": "oxlint src/"
+    "lint": "oxlint src/",
+    "test": "jest"
   },
   "dependencies": {
     "@arizeai/openinference-semantic-conventions": "^2.3.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.9.0",
+    "jest": "^30.4.2",
     "oxlint": "^0.13.0",
+    "ts-jest": "^29.4.11",
     "typescript": "^5.4.5"
   }
 }