@purista/harness 1.0.0 → 1.2.0

package/dist/harness/defineHarness.d.ts

@@ -2,10 +2,13 @@ import { z } from 'zod';
 import { type Logger } from '../logger/index.js';
 import type { ModelAlias, ModelCapability, TokenUsage } from '../ports/model-provider.js';
 import type { StateStore } from '../ports/state.js';
-import type { TelemetryShim } from '../telemetry/index.js';
+import type { Metrics, TelemetryShim } from '../telemetry/index.js';
 import type { HarnessAdapterContext } from '../ports/harness-context.js';
+import type { MemoryAdapter, MemoryFacade, SessionMemory } from '../ports/memory.js';
+import type { DurableWorkspaceStore } from '../ports/workspace.js';
 import type { JsonValue } from '../models/json.js';
 import type { Message } from '../models/state.js';
+import type { RunStatus } from '../models/state.js';
 import type { HarnessError } from '../errors/harness-error.js';
 import { type Sandbox } from '../sandbox/index.js';
 import type { ModelHandle } from '../models/registry.js';
@@ -13,12 +16,13 @@ import { type AdapterCapability, type DurableRuntimeAdapter, type HarnessInspect
 /** Stable harness version string for diagnostics and generated documentation. */
 export declare const HARNESS_VERSION = "0.0.0";
 /** OpenTelemetry capture controls used by the harness. */
+export type TelemetryFlavor = 'dual' | 'gen_ai_only' | 'openinference_only';
+export type ContentCaptureMode = 'NO_CONTENT' | 'SPAN_ONLY' | 'EVENT_ONLY' | 'SPAN_AND_EVENT';
 export interface TelemetryOptions {
-    /**
-     * When `true`, emitted telemetry may include full prompt/message content.
-     * The default is `false` to avoid accidental sensitive-content capture.
-     */
-    captureContent?: boolean;
+    /** Backend emission shape. */
+    flavor?: TelemetryFlavor;
+    /** Span/event content capture mode. */
+    contentCaptureMode?: ContentCaptureMode;
 }
 /** Default harness budgets and execution behavior. */
 export interface HarnessDefaults {
@@ -51,6 +55,12 @@ export interface InvokeOptions {
     timeoutMs?: number;
     /** Optional history-window override for this call only. */
     historyWindow?: number;
+    /** Optional W3C Trace Context parent. */
+    traceparent?: string;
+    /** Optional W3C Trace Context state. */
+    tracestate?: string;
+    /** Scalar metadata exposed to handlers and telemetry sanitizers. */
+    metadata?: Record<string, JsonValue>;
 }
 /** Canonical built-in tool names provided by the harness. */
 export type BuiltinToolName = 'bash' | 'read' | 'write' | 'edit' | 'glob' | 'grep' | 'list';
@@ -91,27 +101,47 @@ export interface PermissionContext {
 export type PermissionDecision = 'allow' | 'deny';
 /** Async permission hook used for interactive approvals or custom policy engines. */
 export type OnPermission = (ctx: PermissionContext) => Promise<PermissionDecision>;
+/** Skill frontmatter parsed from `SKILL.md`. */
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    'allowed-tools'?: string;
+}
+/** Validation mode for `SKILL.md` frontmatter. */
+export type SkillValidationMode = 'strict' | 'lenient';
+/** Diagnostic produced while parsing or discovering skills. */
+export interface SkillDiagnostic {
+    level: 'warn' | 'error';
+    code: 'missing_skill_md' | 'invalid_frontmatter' | 'missing_description' | 'invalid_name' | 'name_mismatch' | 'directory_missing' | 'collision_shadowed' | 'untrusted_project_skill' | 'scan_limit_reached';
+    message: string;
+    skillName?: string;
+    directory?: string;
+    source?: string;
+}
 /** Mounted skill metadata after frontmatter parsing. */
 export interface ResolvedSkill {
     /** Public skill id. */
     name: string;
     /** Short user-facing description from frontmatter. */
     description: string;
-    /** Optional skill version. */
-    version?: string;
     /** Absolute directory mounted into `/skills/<name>`. */
     directory: string;
-}
-/** Sandbox-backed per-session memory facade. */
-export interface SessionMemory {
-    /** Reads `/memory/<key>.json` and returns the parsed JSON value if present. */
-    read<T = JsonValue>(key: string): Promise<T | undefined>;
-    /** Writes JSON-serializable data to `/memory/<key>.json`. */
-    write(key: string, value: JsonValue): Promise<void>;
-    /** Deletes `/memory/<key>.json` if it exists. */
-    delete(key: string): Promise<void>;
-    /** Lists known memory keys without the `.json` suffix. */
-    list(): Promise<string[]>;
+    /** Absolute path to the parsed `SKILL.md`. */
+    skillPath: string;
+    /** Absolute path exposed as the skill instruction file location. */
+    location: string;
+    /** Sandbox mount path for this skill. */
+    mountPath: `/skills/${string}`;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string;
+    trust: 'trusted' | 'project' | 'user';
+    source?: string;
+    diagnostics: readonly SkillDiagnostic[];
 }
 /** Conversation history accessor for a single session thread. */
 export interface ConversationHistory {
@@ -127,6 +157,8 @@ export interface ToolHandlerContext {
     sandbox: import('../sandbox/index.js').SandboxSession;
     logger: Logger;
     telemetry: TelemetryShim;
+    metrics: Metrics;
+    memory: MemoryFacade;
     runId: string;
     sessionId: string;
     agentId: string;
@@ -214,9 +246,32 @@ export type ToolsConfig = Record<string, ToolDefinition>;
 export interface SkillDefinition {
     /** Absolute path to the directory containing `SKILL.md`. */
     directory: string;
+    validationMode?: SkillValidationMode;
+    trust?: 'trusted' | 'project' | 'user';
+    source?: string;
 }
 /** Full skill registry shape. */
 export type SkillsConfig = Record<string, SkillDefinition>;
+/** Options for local Agent Skills discovery. */
+export interface DiscoverSkillsOptions {
+    projectRoot?: string;
+    clientName?: string;
+    includeProjectAgentsDir?: boolean;
+    includeProjectClientDir?: boolean;
+    includeUserAgentsDir?: boolean;
+    includeUserClientDir?: boolean;
+    includeClaudeCompatDir?: boolean;
+    includeAncestorProjectDirs?: boolean;
+    trustedProjectRoots?: readonly string[];
+    validationMode?: SkillValidationMode;
+    maxDepth?: number;
+    maxDirectories?: number;
+}
+/** Result of local Agent Skills discovery. */
+export interface DiscoveredSkills {
+    skills: SkillsConfig;
+    diagnostics: readonly SkillDiagnostic[];
+}
 /** Alias map passed to `.models(...)`. */
 export type ModelsConfig = Record<string, ModelAlias>;
 /** Builder-state accumulator used for type propagation across the fluent harness builder. */
@@ -258,7 +313,9 @@ export interface AgentContextMinimal<S extends BuilderState, I> {
     sessionId: string;
     runId: string;
     history: ConversationHistory;
-    memory: SessionMemory;
+    memory: MemoryFacade;
+    metadata: Readonly<Record<string, JsonValue>>;
+    metrics: Metrics;
 }
 /** Full context passed to workflow handlers. */
 export interface WorkflowContext<S extends BuilderState, I, O> {
@@ -270,6 +327,9 @@ export interface WorkflowContext<S extends BuilderState, I, O> {
     signal: AbortSignal;
     runId: string;
     sessionId: string;
+    metadata: Readonly<Record<string, JsonValue>>;
+    memory: MemoryFacade;
+    metrics: Metrics;
     output?: O;
 }
 /** Full context passed to custom agent handlers. */
@@ -442,6 +502,7 @@ export interface Session<S extends BuilderState> {
     };
     memory: SessionMemory;
     history: ConversationHistory;
+    getRunSummary(runId: string): Promise<RunSummary | undefined>;
     clearHistory(): Promise<void>;
     replaceHistory(messages: ReadonlyArray<Omit<Message, 'id' | 'timestamp'>>): Promise<void>;
     close(): Promise<void>;
@@ -454,6 +515,18 @@ export interface SerializedError {
     message: string;
     meta?: Record<string, unknown>;
 }
+export interface RunSummary {
+    runId: string;
+    sessionId: string;
+    status: RunStatus;
+    startedAt: string;
+    finishedAt?: string;
+    tokenTotals: TokenUsage;
+    modelCalls: number;
+    toolCalls: number;
+    agentCalls: number;
+    error?: SerializedError;
+}
 /** Harness streaming events emitted from `session.workflows.<id>.stream(...)`. */
 export type RunEvent = {
     type: 'run.started';
@@ -512,6 +585,7 @@ export type RunEvent = {
     runId: string;
     agentId?: string;
     object: JsonValue;
+    usage?: TokenUsage;
 } | {
     type: 'model.embedding.completed';
     runId: string;
@@ -538,7 +612,9 @@ export interface HarnessBuilder<S extends BuilderState = {}> {
     logger(logger: Logger): HarnessBuilder<S>;
     state(store: StateStore): HarnessBuilder<S>;
     sandbox(sandbox?: Sandbox<any>): HarnessBuilder<S>;
+    memory(adapter: MemoryAdapter): HarnessBuilder<S>;
     runtime(runtime: DurableRuntimeAdapter): HarnessBuilder<S>;
+    workspaceStore(store: DurableWorkspaceStore): HarnessBuilder<S>;
     requires(capabilities: readonly AdapterCapability[]): HarnessBuilder<S>;
     defaults(defaults: HarnessDefaults): HarnessBuilder<S>;
     models<const M extends ModelsConfig>(models: M): HarnessBuilder<S & {

package/dist/harness/defineHarness.js

@@ -1,5 +1,8 @@
 import { z } from 'zod';
 import { JsonLogger } from '../logger/index.js';
+import { sandboxMemory } from '../memory/sandbox/index.js';
+import { validateMemoryAdapter } from '../ports/memory.js';
+import { validateDurableWorkspaceStore } from '../ports/workspace.js';
 import { InMemoryStateStore } from '../state/in-memory.js';
 import { HarnessConfigError } from '../errors/catalog.js';
 import { autoDetectSandbox } from '../sandbox/index.js';
@@ -26,9 +29,23 @@ class Builder {
     sandbox(sandbox = autoDetectSandbox()) {
         return this.clone({ sandbox });
     }
+    memory(memory) {
+        if (this.configured.memory) {
+            throw new HarnessConfigError('Memory adapter is already configured.', { reason: 'duplicate_adapter', path: 'memory' });
+        }
+        validateMemoryAdapter(memory);
+        return this.clone({ memory });
+    }
     runtime(runtime) {
         return this.clone({ runtime });
     }
+    workspaceStore(workspaceStore) {
+        if (this.configured.workspaceStore) {
+            throw new HarnessConfigError('Workspace store is already configured.', { reason: 'duplicate_adapter', path: 'workspaceStore' });
+        }
+        validateDurableWorkspaceStore(workspaceStore);
+        return this.clone({ workspaceStore });
+    }
     requires(capabilities) {
         return this.clone({ requiredCapabilities: uniqueCapabilities(capabilities) });
     }
@@ -54,6 +71,7 @@ class Builder {
         const resolved = typeof agents === 'function'
             ? agents({ agent: (definition) => definition })
             : agents;
+        this.validateAgentSkillReferences(resolved);
         return this.clone({ agents: resolved });
     }
     workflows(workflows) {
@@ -68,7 +86,11 @@ class Builder {
             throw new HarnessConfigError('At least one model alias is required.', { reason: 'missing_models', path: 'models' });
         }
         const sandbox = this.configured.sandbox ?? autoDetectSandbox();
-        const inspection = this.resolveInspection(this.options.name ?? 'agent-harness', sandbox, models);
+        const memory = this.configured.memory ?? sandboxMemory();
+        validateMemoryAdapter(memory);
+        if (this.configured.workspaceStore)
+            validateDurableWorkspaceStore(this.configured.workspaceStore);
+        const inspection = this.resolveInspection(this.options.name ?? 'agent-harness', sandbox, memory, models);
         const missing = missingCapabilities(inspection.requiredCapabilities, inspection.capabilities);
         if (missing.length > 0) {
             throw new HarnessConfigError('Required adapter capabilities are not available.', {
@@ -83,6 +105,7 @@ class Builder {
             ...(this.configured.telemetry ? { telemetry: this.configured.telemetry } : {}),
             state: this.configured.state ?? new InMemoryStateStore(),
             sandbox,
+            memory,
             defaults: {
                 agentMaxIterations: this.configured.defaults?.agentMaxIterations ?? 16,
                 runTimeoutMs: this.configured.defaults?.runTimeoutMs ?? 600_000,
@@ -103,7 +126,21 @@ class Builder {
     clone(patch) {
         return new Builder(this.options, { ...this.configured, ...patch });
     }
-    resolveInspection(name, sandbox, models) {
+    validateAgentSkillReferences(agents) {
+        const configuredSkills = new Set(Object.keys(this.configured.skills ?? {}));
+        for (const [agentId, agent] of Object.entries(agents)) {
+            for (const skillId of agent.skills ?? []) {
+                if (!configuredSkills.has(skillId)) {
+                    throw new HarnessConfigError('Agent references an unknown skill.', {
+                        reason: 'invalid_agent',
+                        path: `agents.${agentId}.skills`,
+                        id: skillId
+                    });
+                }
+            }
+        }
+    }
+    resolveInspection(name, sandbox, memory, models) {
         const adapters = [];
         const sandboxCapabilities = hasAdapterCapabilities(sandbox) ? uniqueCapabilities(sandbox.capabilities) : [];
         adapters.push({
@@ -111,6 +148,15 @@ class Builder {
             id: getAdapterId(sandbox, 'sandbox'),
             capabilities: sandboxCapabilities
         });
+        adapters.push({
+            kind: 'memory',
+            id: memory.info.id,
+            capabilities: uniqueCapabilities(memory.info.capabilities),
+            metadata: {
+                packageName: memory.info.packageName,
+                ...(memory.info.version ? { version: memory.info.version } : {})
+            }
+        });
         if (this.configured.runtime) {
             adapters.push({
                 kind: 'runtime',
@@ -118,6 +164,17 @@ class Builder {
                 capabilities: uniqueCapabilities(this.configured.runtime.capabilities)
             });
         }
+        if (this.configured.workspaceStore) {
+            adapters.push({
+                kind: 'workspace_store',
+                id: this.configured.workspaceStore.info.id,
+                capabilities: uniqueCapabilities(this.configured.workspaceStore.info.capabilities),
+                metadata: {
+                    packageName: this.configured.workspaceStore.info.packageName,
+                    policy: this.configured.workspaceStore.info.policy
+                }
+            });
+        }
         for (const [alias, model] of Object.entries(models)) {
             adapters.push({
                 kind: 'model',

package/dist/index.d.ts

@@ -9,6 +9,10 @@ export * from './state/in-memory.js';
 export * from './models/json.js';
 export type { SessionRecord, Message, RunRecord, PersistedRunEvent, RunStatus } from './models/state.js';
 export * from './models/registry.js';
+export * from './eval/index.js';
+export * from './memory/sandbox/index.js';
+export * from './skills/index.js';
 export * from './sandbox/index.js';
+export * from './workspace/index.js';
 export * from './tools/mcp/index.js';
 export * from './harness/defineHarness.js';

package/dist/index.js

@@ -7,6 +7,10 @@ export { createDurableWorkflowContext, DurableStepError, DurableRunLeaseError, D
 export * from './state/in-memory.js';
 export * from './models/json.js';
 export * from './models/registry.js';
+export * from './eval/index.js';
+export * from './memory/sandbox/index.js';
+export * from './skills/index.js';
 export * from './sandbox/index.js';
+export * from './workspace/index.js';
 export * from './tools/mcp/index.js';
 export * from './harness/defineHarness.js';

package/dist/memory/sandbox/index.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryAdapter } from '../../ports/memory.js';
+/**
+ * Creates the built-in memory adapter backed by the current session sandbox.
+ *
+ * It is intentionally simple and local: session memory is stored below
+ * `/memory/session/`, run memory below `/memory/runs/<runId>/`.
+ *
+ * @example
+ * ```ts
+ * const harness = defineHarness()
+ *   .memory(sandboxMemory())
+ *   .models({ fast: model })
+ *   .agents(({ agent }) => ({ assistant: agent({ model: 'fast', instructions: 'Help.' }) }))
+ *   .build()
+ * ```
+ */
+export declare function sandboxMemory(): MemoryAdapter;

package/dist/memory/sandbox/index.js

@@ -0,0 +1,122 @@
+import { StateError } from '../../errors/index.js';
+/**
+ * Creates the built-in memory adapter backed by the current session sandbox.
+ *
+ * It is intentionally simple and local: session memory is stored below
+ * `/memory/session/`, run memory below `/memory/runs/<runId>/`.
+ *
+ * @example
+ * ```ts
+ * const harness = defineHarness()
+ *   .memory(sandboxMemory())
+ *   .models({ fast: model })
+ *   .agents(({ agent }) => ({ assistant: agent({ model: 'fast', instructions: 'Help.' }) }))
+ *   .build()
+ * ```
+ */
+export function sandboxMemory() {
+    return new SandboxMemoryAdapter();
+}
+class SandboxMemoryAdapter {
+    info = {
+        id: 'sandbox_memory',
+        packageName: '@purista/harness',
+        capabilities: ['memory.kv', 'memory.list', 'memory.delete', 'memory.run', 'memory.session']
+    };
+    capabilities = this.info.capabilities;
+    configureHarnessContext(_context) {
+        // The sandbox adapter receives runtime context through each `open(...)` call.
+    }
+    async open(scope, ctx) {
+        const sandbox = ctx.sandbox;
+        if (!sandbox) {
+            throw new StateError('sandboxMemory requires an active sandbox session.', {
+                op: 'memory.get',
+                adapter: 'memory',
+                memory_provider: this.info.id,
+                reason: 'missing_sandbox'
+            });
+        }
+        const root = scopeRoot(scope);
+        const metaRoot = scopeMetaRoot(scope);
+        return {
+            get: async (key, op) => {
+                op.signal.throwIfAborted();
+                const path = `${root}/${key}.json`;
+                if (!(await sandbox.exists(path)))
+                    return undefined;
+                return JSON.parse(await sandbox.readText(path));
+            },
+            set: async (key, value, op) => {
+                op.signal.throwIfAborted();
+                const existing = await readMetadata(sandbox, metaRoot, key);
+                const now = new Date().toISOString();
+                await sandbox.write(`${root}/${key}.json`, JSON.stringify(value));
+                await sandbox.write(`${metaRoot}/${key}.json`, JSON.stringify({
+                    createdAt: existing?.createdAt ?? now,
+                    updatedAt: now,
+                    ...(op.opts?.tags ? { tags: op.opts.tags } : existing?.tags ? { tags: existing.tags } : {}),
+                    ...(op.opts?.metadata ? { metadata: op.opts.metadata } : existing?.metadata ? { metadata: existing.metadata } : {})
+                }));
+            },
+            delete: async (key, op) => {
+                op.signal.throwIfAborted();
+                await sandbox.remove(`${root}/${key}.json`).catch(() => undefined);
+                await sandbox.remove(`${metaRoot}/${key}.json`).catch(() => undefined);
+            },
+            list: async (op) => {
+                op.signal.throwIfAborted();
+                const entries = await sandbox.list(root).catch(() => []);
+                const opts = op.opts ?? {};
+                const keys = entries
+                    .filter((entry) => entry.kind === 'file' && entry.name.endsWith('.json'))
+                    .map((entry) => entry.name.slice(0, -5))
+                    .filter((key) => !opts.prefix || key.startsWith(opts.prefix))
+                    .filter((key) => !opts.cursor || key > opts.cursor)
+                    .sort()
+                    .slice(0, opts.limit);
+                const out = [];
+                for (const key of keys) {
+                    const metadata = await readMetadata(sandbox, metaRoot, key);
+                    out.push({ key, ...(metadata ?? {}) });
+                }
+                return out;
+            }
+        };
+    }
+}
+function scopeRoot(scope) {
+    if (scope.kind === 'session')
+        return '/memory/session';
+    if (scope.kind === 'run' && scope.runId)
+        return `/memory/runs/${scope.runId}`;
+    throw new StateError('Unsupported sandbox memory scope.', {
+        op: 'memory.get',
+        adapter: 'memory',
+        memory_provider: 'sandbox_memory',
+        reason: `unsupported_scope:${scope.kind}`
+    });
+}
+function scopeMetaRoot(scope) {
+    if (scope.kind === 'session')
+        return '/memory/.meta/session';
+    if (scope.kind === 'run' && scope.runId)
+        return `/memory/.meta/runs/${scope.runId}`;
+    throw new StateError('Unsupported sandbox memory scope.', {
+        op: 'memory.list',
+        adapter: 'memory',
+        memory_provider: 'sandbox_memory',
+        reason: `unsupported_scope:${scope.kind}`
+    });
+}
+async function readMetadata(sandbox, metaRoot, key) {
+    const path = `${metaRoot}/${key}.json`;
+    if (!(await sandbox.exists(path).catch(() => false)))
+        return undefined;
+    try {
+        return JSON.parse(await sandbox.readText(path));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/models/registry.js

@@ -131,10 +131,13 @@ function withModelStreamSpan(options, aliasKey, alias, method, ctx, fn) {
             span.setAttributes({
                 [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: lastUsage.inputTokens,
                 [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: lastUsage.outputTokens,
-                'gen_ai.usage.total_tokens': lastUsage.totalTokens
+                'gen_ai.usage.total_tokens': lastUsage.totalTokens,
+                'llm.token_count.prompt': lastUsage.inputTokens,
+                'llm.token_count.completion': lastUsage.outputTokens,
+                'llm.token_count.total': lastUsage.totalTokens
             });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', lastUsage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', lastUsage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', lastUsage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', lastUsage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
         }
         if (lastFinishReason)
             span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [lastFinishReason]);
@@ -188,10 +191,13 @@ async function withModelSpan(options, aliasKey, alias, method, ctx, fn) {
             span.setAttributes({
                 [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: usage.inputTokens,
                 [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: usage.outputTokens,
-                'gen_ai.usage.total_tokens': usage.totalTokens
+                'gen_ai.usage.total_tokens': usage.totalTokens,
+                'llm.token_count.prompt': usage.inputTokens,
+                'llm.token_count.completion': usage.outputTokens,
+                'llm.token_count.total': usage.totalTokens
             });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', usage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
-            options.telemetry?.recordCounter('gen_ai.client.token.usage', usage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', usage.inputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_INPUT });
+            options.telemetry?.recordHistogram('gen_ai.client.token.usage', usage.outputTokens, { ...attrs, [ATTR_GEN_AI_TOKEN_TYPE]: GEN_AI_TOKEN_TYPE_VALUE_OUTPUT });
         }
         if (finishReason)
             span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [finishReason]);
@@ -208,11 +214,30 @@ function modelSpanAttrs(options, aliasKey, alias, method, ctx) {
         'harness.agent.id': ctx?.agentId,
         'harness.model.alias': aliasKey,
         'harness.model.method': method,
+        'gen_ai.operation.name': genAiOperationName(method),
+        'openinference.span.kind': openInferenceSpanKind(method),
         [ATTR_GEN_AI_SYSTEM]: alias.provider.genAiSystem,
+        'gen_ai.provider.name': alias.provider.genAiSystem,
         [ATTR_GEN_AI_REQUEST_MODEL]: alias.model,
-        'model.provider': alias.provider.id
+        'model.provider': alias.provider.id,
+        'llm.provider': alias.provider.genAiSystem,
+        'llm.model_name': alias.model
     };
 }
+function genAiOperationName(method) {
+    if (method === 'embeddings')
+        return 'embeddings';
+    if (method === 'rerank')
+        return undefined;
+    return 'chat';
+}
+function openInferenceSpanKind(method) {
+    if (method === 'embeddings')
+        return 'EMBEDDING';
+    if (method === 'rerank')
+        return 'RERANKER';
+    return 'LLM';
+}
 /**
  * Validates alias capabilities for the requested operation.
  *

package/dist/ports/capabilities.d.ts

@@ -25,15 +25,59 @@ export type AdapterCapability =
  | 'runtime.distributed_lock'
 /** Runtime can resume from committed checkpoints. */
  | 'runtime.resume_from_checkpoint'
+/** Runtime checkpoint records can carry durable workspace references. */
+ | 'runtime.workspace_checkpoint'
+/** Runtime exposes checkpoint retention and expiry metadata. */
+ | 'runtime.checkpoint_retention'
+/** Workspace store persists state beyond process exit. */
+ | 'workspace_store.durable'
+/** Workspace store can produce stable checkpoints. */
+ | 'workspace_store.checkpoint'
+/** Workspace store can resume committed checkpoints. */
+ | 'workspace_store.resume'
+/** Workspace store can abort active or paused workspaces. */
+ | 'workspace_store.abort'
+/** Workspace store supports idempotent cleanup. */
+ | 'workspace_store.cleanup'
+/** Workspace store supports read-only inspection. */
+ | 'workspace_store.inspect'
+/** Workspace store exposes retention policy and expiry metadata. */
+ | 'workspace_store.retention'
+/** Workspace store enforces and reports quota policy. */
+ | 'workspace_store.quota'
+/** Workspace store encrypts checkpoint, snapshot, file, and metadata storage. */
+ | 'workspace_store.encrypted_storage'
 /** Adapter can record feedback. */
- | 'feedback.record';
+ | 'feedback.record'
+/** Memory adapter supports key/value reads and writes. */
+ | 'memory.kv'
+/** Memory adapter supports key listing. */
+ | 'memory.list'
+/** Memory adapter supports key deletion. */
+ | 'memory.delete'
+/** Memory adapter supports text search over stored memory. */
+ | 'memory.search'
+/** Memory adapter supports entry expiration. */
+ | 'memory.ttl'
+/** Memory adapter supports run-scoped memory. */
+ | 'memory.run'
+/** Memory adapter supports session-scoped memory. */
+ | 'memory.session'
+/** Memory adapter supports agent-scoped memory. */
+ | 'memory.agent'
+/** Memory adapter supports user-scoped memory. */
+ | 'memory.user'
+/** Memory adapter supports tenant-scoped memory. */
+ | 'memory.tenant'
+/** Memory survives adapter close/reopen for the same logical scope. */
+ | 'memory.persistent';
 /** Data-only descriptor implemented by adapters that expose capability metadata. */
 export interface AdapterCapabilities {
     readonly capabilities: readonly AdapterCapability[];
 }
 /** Adapter descriptor surfaced through `harness.inspect()`. */
 export interface AdapterInspection {
-    readonly kind: 'state' | 'sandbox' | 'runtime' | 'feedback' | 'model';
+    readonly kind: 'state' | 'sandbox' | 'runtime' | 'workspace_store' | 'feedback' | 'model' | 'memory';
     readonly id: string;
     readonly capabilities: readonly AdapterCapability[];
     readonly metadata?: Record<string, unknown>;

package/dist/ports/harness-context.d.ts

@@ -1,10 +1,13 @@
 import type { Logger } from '../logger/index.js';
-import type { TelemetryShim } from '../telemetry/index.js';
+import type { Metrics, TelemetryShim } from '../telemetry/index.js';
+import type { ContentCaptureMode } from '../harness/defineHarness.js';
 /** Harness-level context inherited by adapters registered with the harness. */
 export interface HarnessAdapterContext {
     harnessName: string;
     logger: Logger;
     telemetry: TelemetryShim;
+    metrics: Metrics;
+    contentCaptureMode: ContentCaptureMode;
     defaults: {
         agentMaxIterations: number;
         runTimeoutMs: number;

package/dist/ports/index.d.ts

@@ -4,3 +4,5 @@ export * from './state.js';
 export * from './harness-context.js';
 export * from './capabilities.js';
 export * from './feedback.js';
+export * from './memory.js';
+export * from './workspace.js';

package/dist/ports/index.js

@@ -4,3 +4,5 @@ export * from './state.js';
 export * from './harness-context.js';
 export * from './capabilities.js';
 export * from './feedback.js';
+export * from './memory.js';
+export * from './workspace.js';

package/dist/ports/memory/facade.d.ts

@@ -0,0 +1,5 @@
+import type { CreateMemoryFacadeOptions, MemoryFacade, MemoryScope, SessionMemory } from './types.js';
+/** Creates scoped memory helpers for a concrete session/run context. */
+export declare function createMemoryFacade(opts: CreateMemoryFacadeOptions): MemoryFacade;
+/** Creates a key/value memory facade bound to one normalized scope. */
+export declare function createSessionMemory(opts: CreateMemoryFacadeOptions, scope: MemoryScope): SessionMemory;