@lensagent/core 0.1.0

package/dist/config/schema.d.ts

@@ -0,0 +1,292 @@
+import { type Static } from '@sinclair/typebox';
+export declare const ModelHarnessProfileSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TInteger;
+    systemPrompt: import("@sinclair/typebox").TObject<{
+        sourceVersion: import("@sinclair/typebox").TString;
+        content: import("@sinclair/typebox").TString;
+        container: import("@sinclair/typebox").TLiteral<"system">;
+    }>;
+    context: import("@sinclair/typebox").TObject<{
+        segmentOrder: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        preserveProviderVisibleOrder: import("@sinclair/typebox").TLiteral<true>;
+        allowExternalTransforms: import("@sinclair/typebox").TLiteral<false>;
+    }>;
+    semantics: import("@sinclair/typebox").TObject<{
+        reasoningStateRoundTrip: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"required">, import("@sinclair/typebox").TLiteral<"optional">, import("@sinclair/typebox").TLiteral<"forbidden">]>;
+        thinkingContinuation: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"required">, import("@sinclair/typebox").TLiteral<"optional">, import("@sinclair/typebox").TLiteral<"forbidden">]>;
+        toolResultOrder: import("@sinclair/typebox").TLiteral<"call_ordinal">;
+        structuredOutput: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"supported">, import("@sinclair/typebox").TLiteral<"unsupported">]>;
+        toolDescriptionStyle: import("@sinclair/typebox").TString;
+        recoveryConstraints: import("@sinclair/typebox").TObject<{
+            partialResponseResume: import("@sinclair/typebox").TLiteral<"forbidden">;
+            preserveReasoningState: import("@sinclair/typebox").TBoolean;
+        }>;
+    }>;
+    ptc: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        enabledByDefault: import("@sinclair/typebox").TBoolean;
+        maxToolCalls: import("@sinclair/typebox").TInteger;
+        schemaVersion: import("@sinclair/typebox").TString;
+        instruction: import("@sinclair/typebox").TString;
+    }>>;
+    effort: import("@sinclair/typebox").TObject<{
+        allowed: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        default: import("@sinclair/typebox").TString;
+    }>;
+    cache: import("@sinclair/typebox").TObject<{
+        enabledByDefault: import("@sinclair/typebox").TBoolean;
+        minimumEligiblePrefixTokens: import("@sinclair/typebox").TInteger;
+        maximumBreakpoints: import("@sinclair/typebox").TInteger;
+        segmentStability: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"stable">, import("@sinclair/typebox").TLiteral<"dynamic">, import("@sinclair/typebox").TLiteral<"unknown">]>>;
+    }>;
+}>;
+export declare const ConfigSchema: import("@sinclair/typebox").TObject<{
+    listen: import("@sinclair/typebox").TObject<{
+        host: import("@sinclair/typebox").TString;
+        port: import("@sinclair/typebox").TInteger;
+    }>;
+    tls: import("@sinclair/typebox").TObject<{
+        enabled: import("@sinclair/typebox").TBoolean;
+        certFile: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+        keyFile: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+    }>;
+    database: import("@sinclair/typebox").TObject<{
+        path: import("@sinclair/typebox").TString;
+    }>;
+    pairPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    shutdown: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        graceMs: import("@sinclair/typebox").TInteger;
+    }>>;
+    executor: import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        identityPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        tls: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabled: import("@sinclair/typebox").TBoolean;
+            caFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            certFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            keyFile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>>;
+    }>;
+    artifacts: import("@sinclair/typebox").TObject<{
+        directory: import("@sinclair/typebox").TString;
+    }>;
+    persistence: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        eventLog: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabled: import("@sinclair/typebox").TBoolean;
+            path: import("@sinclair/typebox").TString;
+            fsync: import("@sinclair/typebox").TBoolean;
+        }>>;
+        contentStore: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            mode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"filesystem">, import("@sinclair/typebox").TLiteral<"content_addressed">]>;
+        }>>;
+    }>>;
+    observability: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        logs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabled: import("@sinclair/typebox").TBoolean;
+            path: import("@sinclair/typebox").TString;
+            maxFileBytes: import("@sinclair/typebox").TInteger;
+            maxFiles: import("@sinclair/typebox").TInteger;
+            retentionDays: import("@sinclair/typebox").TInteger;
+        }>>;
+        traces: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            capacity: import("@sinclair/typebox").TInteger;
+        }>>;
+    }>>;
+    mcpServers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        endpoint: import("@sinclair/typebox").TString;
+        headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+            env: import("@sinclair/typebox").TString;
+            optional: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        }>]>>>;
+        timeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        outputLimitBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>>>;
+    lspServers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        command: import("@sinclair/typebox").TString;
+        args: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        project: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        initializationOptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        maxFrameBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxBufferBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>>>;
+    providers: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        adapter: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"@ai-sdk/openai">, import("@sinclair/typebox").TLiteral<"@ai-sdk/anthropic">, import("@sinclair/typebox").TLiteral<"@ai-sdk/openai-compatible">]>;
+        options: import("@sinclair/typebox").TObject<{
+            apiKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+                env: import("@sinclair/typebox").TString;
+                optional: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            }>]>>;
+            baseURL: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+        }>;
+        models: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+            contextWindowTokens: import("@sinclair/typebox").TInteger;
+            wireModel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            harnessProfile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            usageReliable: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            cacheSupported: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            programmaticToolCallingSupported: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        }>>;
+    }>>;
+    modelHarnessProfiles: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        version: import("@sinclair/typebox").TInteger;
+        systemPrompt: import("@sinclair/typebox").TObject<{
+            sourceVersion: import("@sinclair/typebox").TString;
+            content: import("@sinclair/typebox").TString;
+            container: import("@sinclair/typebox").TLiteral<"system">;
+        }>;
+        context: import("@sinclair/typebox").TObject<{
+            segmentOrder: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            preserveProviderVisibleOrder: import("@sinclair/typebox").TLiteral<true>;
+            allowExternalTransforms: import("@sinclair/typebox").TLiteral<false>;
+        }>;
+        semantics: import("@sinclair/typebox").TObject<{
+            reasoningStateRoundTrip: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"required">, import("@sinclair/typebox").TLiteral<"optional">, import("@sinclair/typebox").TLiteral<"forbidden">]>;
+            thinkingContinuation: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"required">, import("@sinclair/typebox").TLiteral<"optional">, import("@sinclair/typebox").TLiteral<"forbidden">]>;
+            toolResultOrder: import("@sinclair/typebox").TLiteral<"call_ordinal">;
+            structuredOutput: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"supported">, import("@sinclair/typebox").TLiteral<"unsupported">]>;
+            toolDescriptionStyle: import("@sinclair/typebox").TString;
+            recoveryConstraints: import("@sinclair/typebox").TObject<{
+                partialResponseResume: import("@sinclair/typebox").TLiteral<"forbidden">;
+                preserveReasoningState: import("@sinclair/typebox").TBoolean;
+            }>;
+        }>;
+        ptc: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            enabledByDefault: import("@sinclair/typebox").TBoolean;
+            maxToolCalls: import("@sinclair/typebox").TInteger;
+            schemaVersion: import("@sinclair/typebox").TString;
+            instruction: import("@sinclair/typebox").TString;
+        }>>;
+        effort: import("@sinclair/typebox").TObject<{
+            allowed: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            default: import("@sinclair/typebox").TString;
+        }>;
+        cache: import("@sinclair/typebox").TObject<{
+            enabledByDefault: import("@sinclair/typebox").TBoolean;
+            minimumEligiblePrefixTokens: import("@sinclair/typebox").TInteger;
+            maximumBreakpoints: import("@sinclair/typebox").TInteger;
+            segmentStability: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"stable">, import("@sinclair/typebox").TLiteral<"dynamic">, import("@sinclair/typebox").TLiteral<"unknown">]>>;
+        }>;
+    }>>>;
+    roles: import("@sinclair/typebox").TObject<{
+        agent: import("@sinclair/typebox").TObject<{
+            model: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            modelReasoningEffort: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            policyPreset: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            capabilities: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            contextStrategy: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            providerRouting: import("@sinclair/typebox").TObject<{
+                retryMaxAttempts: import("@sinclair/typebox").TInteger;
+                fallback: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>;
+        }>;
+        subagent: import("@sinclair/typebox").TObject<{
+            model: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            modelReasoningEffort: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            policyPreset: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            capabilities: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            contextStrategy: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            providerRouting: import("@sinclair/typebox").TObject<{
+                retryMaxAttempts: import("@sinclair/typebox").TInteger;
+                fallback: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>;
+        }>;
+        compactor: import("@sinclair/typebox").TObject<{
+            model: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            modelReasoningEffort: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            policyPreset: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            capabilities: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            contextStrategy: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            providerRouting: import("@sinclair/typebox").TObject<{
+                retryMaxAttempts: import("@sinclair/typebox").TInteger;
+                fallback: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>;
+        }>;
+        'auto-review': import("@sinclair/typebox").TObject<{
+            model: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            modelReasoningEffort: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            policyPreset: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            capabilities: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            contextStrategy: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
+            providerRouting: import("@sinclair/typebox").TObject<{
+                retryMaxAttempts: import("@sinclair/typebox").TInteger;
+                fallback: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            }>;
+        }>;
+    }>;
+    tokenizer: import("@sinclair/typebox").TObject<{
+        mode: import("@sinclair/typebox").TLiteral<"universal_tel">;
+        version: import("@sinclair/typebox").TInteger;
+    }>;
+    policyPresets: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        capabilities: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"read_only">, import("@sinclair/typebox").TLiteral<"workspace_write">, import("@sinclair/typebox").TLiteral<"external">, import("@sinclair/typebox").TLiteral<"ask">, import("@sinclair/typebox").TLiteral<"auto_approve">, import("@sinclair/typebox").TLiteral<"full_access">]>>;
+    }>>;
+    concurrency: import("@sinclair/typebox").TObject<{
+        instanceMax: import("@sinclair/typebox").TInteger;
+        perStepMax: import("@sinclair/typebox").TInteger;
+        perAdapterMax: import("@sinclair/typebox").TInteger;
+    }>;
+    worker: import("@sinclair/typebox").TObject<{
+        timeoutMs: import("@sinclair/typebox").TInteger;
+        outputLimitBytes: import("@sinclair/typebox").TInteger;
+    }>;
+    contextBudget: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        outputReserveTokens: import("@sinclair/typebox").TInteger;
+        safetyMarginTokens: import("@sinclair/typebox").TInteger;
+    }>>;
+    capabilityInput: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        catalogMaxTokens: import("@sinclair/typebox").TInteger;
+        searchResultMaxTokens: import("@sinclair/typebox").TInteger;
+    }>>;
+    contextProjection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        toolResultMaxTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        snip: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            triggerTokens: import("@sinclair/typebox").TInteger;
+            retainedTokens: import("@sinclair/typebox").TInteger;
+        }>>;
+        microcompact: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            triggerTokens: import("@sinclair/typebox").TInteger;
+            projectedTokens: import("@sinclair/typebox").TInteger;
+        }>>;
+        contextCollapse: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            triggerTokens: import("@sinclair/typebox").TInteger;
+            projectedTokens: import("@sinclair/typebox").TInteger;
+        }>>;
+        stageVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+    compaction: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        preservedSegmentTokens: import("@sinclair/typebox").TInteger;
+        preservedSegmentBytes: import("@sinclair/typebox").TInteger;
+        summaryMaxTokens: import("@sinclair/typebox").TInteger;
+    }>>;
+    autoReview: import("@sinclair/typebox").TObject<{
+        timeoutMs: import("@sinclair/typebox").TInteger;
+        goalMaxBytes: import("@sinclair/typebox").TInteger;
+    }>;
+    executive: import("@sinclair/typebox").TObject<{
+        verification: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TString;
+        }>>;
+    }>;
+    providerPromptCache: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        enabled: import("@sinclair/typebox").TBoolean;
+        minimumEligiblePrefixTokens: import("@sinclair/typebox").TInteger;
+        maximumBreakpoints: import("@sinclair/typebox").TInteger;
+    }>>;
+    historyRetention: import("@sinclair/typebox").TObject<{
+        purgeMode: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"manual">, import("@sinclair/typebox").TLiteral<"after_days">]>;
+        purgeArchivedAfterDays: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TInteger, import("@sinclair/typebox").TNull]>;
+    }>;
+    snapshot: import("@sinclair/typebox").TObject<{
+        maxRuntimeEntities: import("@sinclair/typebox").TInteger;
+        pageSizeDefault: import("@sinclair/typebox").TInteger;
+        pageSizeMax: import("@sinclair/typebox").TInteger;
+    }>;
+    sse: import("@sinclair/typebox").TObject<{
+        heartbeatIntervalMs: import("@sinclair/typebox").TInteger;
+        maxBufferedEvents: import("@sinclair/typebox").TInteger;
+        maxBufferedBytes: import("@sinclair/typebox").TInteger;
+    }>;
+}>;
+export type HarnessConfig = Static<typeof ConfigSchema>;
+export type ModelHarnessProfile = Static<typeof ModelHarnessProfileSchema>;

package/dist/config/schema.js

@@ -0,0 +1,177 @@
+import { Type } from '@sinclair/typebox';
+const NullableString = Type.Union([Type.String({ minLength: 1 }), Type.Null()]);
+const PositiveInteger = Type.Integer({ minimum: 1 });
+const Secret = Type.Union([
+    Type.String({ minLength: 1 }),
+    Type.Object({ env: Type.String({ minLength: 1 }), optional: Type.Optional(Type.Boolean()) }, { additionalProperties: false })
+]);
+const Routing = Type.Object({
+    retryMaxAttempts: Type.Integer({ minimum: 1, maximum: 10 }),
+    fallback: Type.Array(Type.String({ minLength: 3 }))
+}, { additionalProperties: false });
+const Role = Type.Object({
+    model: NullableString,
+    modelReasoningEffort: NullableString,
+    policyPreset: NullableString,
+    capabilities: Type.Array(Type.String({ minLength: 1 })),
+    contextStrategy: NullableString,
+    providerRouting: Routing
+}, { additionalProperties: false });
+const SegmentStability = Type.Union([Type.Literal('stable'), Type.Literal('dynamic'), Type.Literal('unknown')]);
+export const ModelHarnessProfileSchema = Type.Object({
+    version: PositiveInteger,
+    systemPrompt: Type.Object({
+        sourceVersion: Type.String({ minLength: 1 }),
+        content: Type.String({ minLength: 1 }),
+        container: Type.Literal('system')
+    }, { additionalProperties: false }),
+    context: Type.Object({
+        segmentOrder: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+        preserveProviderVisibleOrder: Type.Literal(true),
+        allowExternalTransforms: Type.Literal(false)
+    }, { additionalProperties: false }),
+    semantics: Type.Object({
+        reasoningStateRoundTrip: Type.Union([Type.Literal('required'), Type.Literal('optional'), Type.Literal('forbidden')]),
+        thinkingContinuation: Type.Union([Type.Literal('required'), Type.Literal('optional'), Type.Literal('forbidden')]),
+        toolResultOrder: Type.Literal('call_ordinal'),
+        structuredOutput: Type.Union([Type.Literal('supported'), Type.Literal('unsupported')]),
+        toolDescriptionStyle: Type.String({ minLength: 1 }),
+        recoveryConstraints: Type.Object({
+            partialResponseResume: Type.Literal('forbidden'),
+            preserveReasoningState: Type.Boolean()
+        }, { additionalProperties: false })
+    }, { additionalProperties: false }),
+    ptc: Type.Optional(Type.Object({
+        enabledByDefault: Type.Boolean(),
+        maxToolCalls: PositiveInteger,
+        schemaVersion: Type.String({ minLength: 1 }),
+        instruction: Type.String({ minLength: 1 })
+    }, { additionalProperties: false })),
+    effort: Type.Object({
+        allowed: Type.Array(Type.String({ minLength: 1, maxLength: 64, pattern: '^[A-Za-z0-9._:-]+$' }), { minItems: 1, uniqueItems: true }),
+        default: Type.String({ minLength: 1, maxLength: 64, pattern: '^[A-Za-z0-9._:-]+$' })
+    }, { additionalProperties: false }),
+    cache: Type.Object({
+        enabledByDefault: Type.Boolean(),
+        minimumEligiblePrefixTokens: PositiveInteger,
+        maximumBreakpoints: Type.Integer({ minimum: 0 }),
+        segmentStability: Type.Record(Type.String(), SegmentStability)
+    }, { additionalProperties: false })
+}, { additionalProperties: false });
+export const ConfigSchema = Type.Object({
+    listen: Type.Object({ host: Type.String({ minLength: 1 }), port: Type.Integer({ minimum: 1, maximum: 65535 }) }, { additionalProperties: false }),
+    tls: Type.Object({ enabled: Type.Boolean(), certFile: NullableString, keyFile: NullableString }, { additionalProperties: false }),
+    database: Type.Object({ path: Type.String({ minLength: 1 }) }, { additionalProperties: false }),
+    pairPath: Type.Optional(Type.String({ minLength: 1, default: 'config/pair.json' })),
+    // Upper bound on the ordered shutdown. Read only when a stop begins, so a change takes effect on
+    // the next stop and this stays a hot setting rather than a restart-only one.
+    shutdown: Type.Optional(Type.Object({
+        graceMs: Type.Integer({ minimum: 0, maximum: 600000, default: 30000 })
+    }, { additionalProperties: false })),
+    executor: Type.Object({
+        address: Type.String({ minLength: 1 }),
+        identityPath: Type.Optional(Type.String({ minLength: 1 })),
+        tls: Type.Optional(Type.Object({
+            enabled: Type.Boolean(),
+            caFile: Type.Optional(Type.String({ minLength: 1 })),
+            certFile: Type.Optional(Type.String({ minLength: 1 })),
+            keyFile: Type.Optional(Type.String({ minLength: 1 }))
+        }, { additionalProperties: false }))
+    }, { additionalProperties: false }),
+    artifacts: Type.Object({ directory: Type.String({ minLength: 1 }) }, { additionalProperties: false }),
+    persistence: Type.Optional(Type.Object({
+        eventLog: Type.Optional(Type.Object({
+            enabled: Type.Boolean(), path: Type.String({ minLength: 1 }), fsync: Type.Boolean()
+        }, { additionalProperties: false })),
+        contentStore: Type.Optional(Type.Object({ mode: Type.Union([Type.Literal('filesystem'), Type.Literal('content_addressed')]) }, { additionalProperties: false }))
+    }, { additionalProperties: false })),
+    observability: Type.Optional(Type.Object({
+        logs: Type.Optional(Type.Object({
+            enabled: Type.Boolean(),
+            path: Type.String({ minLength: 1 }),
+            maxFileBytes: PositiveInteger,
+            maxFiles: PositiveInteger,
+            retentionDays: PositiveInteger
+        }, { additionalProperties: false })),
+        traces: Type.Optional(Type.Object({ capacity: PositiveInteger }, { additionalProperties: false }))
+    }, { additionalProperties: false })),
+    mcpServers: Type.Optional(Type.Record(Type.String({ pattern: '^[a-z0-9][a-z0-9._-]{0,63}$' }), Type.Object({
+        endpoint: Type.String({ minLength: 1 }),
+        headers: Type.Optional(Type.Record(Type.String(), Secret)),
+        timeoutMs: Type.Optional(PositiveInteger),
+        outputLimitBytes: Type.Optional(PositiveInteger)
+    }, { additionalProperties: false }))),
+    lspServers: Type.Optional(Type.Record(Type.String({ pattern: '^[a-z0-9][a-z0-9._-]{0,63}$' }), Type.Object({
+        command: Type.String({ minLength: 1 }),
+        args: Type.Optional(Type.Array(Type.String())),
+        project: Type.Optional(Type.String()),
+        initializationOptions: Type.Optional(Type.Unknown()),
+        maxFrameBytes: Type.Optional(PositiveInteger),
+        maxBufferBytes: Type.Optional(PositiveInteger)
+    }, { additionalProperties: false }))),
+    providers: Type.Record(Type.String({ minLength: 1 }), Type.Object({
+        adapter: Type.Union([
+            Type.Literal('@ai-sdk/openai'),
+            Type.Literal('@ai-sdk/anthropic'),
+            Type.Literal('@ai-sdk/openai-compatible')
+        ]),
+        options: Type.Object({
+            apiKey: Type.Optional(Secret),
+            baseURL: Type.Optional(Type.String({ minLength: 1 })),
+            headers: Type.Optional(Type.Record(Type.String(), Type.String()))
+        }, { additionalProperties: false }),
+        models: Type.Record(Type.String({ minLength: 1 }), Type.Object({
+            contextWindowTokens: PositiveInteger,
+            wireModel: Type.Optional(Type.String({ minLength: 1 })),
+            harnessProfile: Type.Optional(Type.String({ minLength: 1 })),
+            usageReliable: Type.Optional(Type.Boolean()),
+            cacheSupported: Type.Optional(Type.Boolean()),
+            programmaticToolCallingSupported: Type.Optional(Type.Boolean())
+        }, { additionalProperties: false }))
+    }, { additionalProperties: false })),
+    modelHarnessProfiles: Type.Optional(Type.Record(Type.String({ minLength: 1 }), ModelHarnessProfileSchema)),
+    roles: Type.Object({ agent: Role, subagent: Role, compactor: Role, 'auto-review': Role }, { additionalProperties: false }),
+    tokenizer: Type.Object({ mode: Type.Literal('universal_tel'), version: Type.Integer({ minimum: 1 }) }, { additionalProperties: false }),
+    policyPresets: Type.Record(Type.String({ minLength: 1 }), Type.Object({
+        capabilities: Type.Record(Type.String(), Type.Union([
+            Type.Literal('read_only'), Type.Literal('workspace_write'), Type.Literal('external'),
+            Type.Literal('ask'), Type.Literal('auto_approve'), Type.Literal('full_access')
+        ]))
+    }, { additionalProperties: false })),
+    concurrency: Type.Object({ instanceMax: PositiveInteger, perStepMax: PositiveInteger, perAdapterMax: PositiveInteger }, { additionalProperties: false }),
+    worker: Type.Object({ timeoutMs: PositiveInteger, outputLimitBytes: PositiveInteger }, { additionalProperties: false }),
+    contextBudget: Type.Optional(Type.Object({ outputReserveTokens: PositiveInteger, safetyMarginTokens: PositiveInteger }, { additionalProperties: false })),
+    capabilityInput: Type.Optional(Type.Object({ catalogMaxTokens: PositiveInteger, searchResultMaxTokens: PositiveInteger }, { additionalProperties: false })),
+    contextProjection: Type.Optional(Type.Object({
+        toolResultMaxTokens: Type.Optional(PositiveInteger),
+        snip: Type.Optional(Type.Object({ triggerTokens: PositiveInteger, retainedTokens: PositiveInteger }, { additionalProperties: false })),
+        microcompact: Type.Optional(Type.Object({ triggerTokens: PositiveInteger, projectedTokens: PositiveInteger }, { additionalProperties: false })),
+        contextCollapse: Type.Optional(Type.Object({ triggerTokens: PositiveInteger, projectedTokens: PositiveInteger }, { additionalProperties: false })),
+        stageVersion: Type.Optional(Type.String({ minLength: 1 }))
+    }, { additionalProperties: false })),
+    compaction: Type.Optional(Type.Object({
+        preservedSegmentTokens: PositiveInteger,
+        preservedSegmentBytes: PositiveInteger,
+        summaryMaxTokens: PositiveInteger
+    }, { additionalProperties: false })),
+    autoReview: Type.Object({ timeoutMs: PositiveInteger, goalMaxBytes: PositiveInteger }, { additionalProperties: false }),
+    executive: Type.Object({
+        verification: Type.Array(Type.Object({
+            id: Type.String({ minLength: 1, maxLength: 128, pattern: '^[A-Za-z0-9._:-]+$' }),
+            description: Type.String({ minLength: 1, maxLength: 4096 })
+        }, { additionalProperties: false }), { maxItems: 128 })
+    }, { additionalProperties: false }),
+    providerPromptCache: Type.Optional(Type.Object({
+        enabled: Type.Boolean(), minimumEligiblePrefixTokens: PositiveInteger, maximumBreakpoints: Type.Integer({ minimum: 0 })
+    }, { additionalProperties: false })),
+    historyRetention: Type.Object({
+        purgeMode: Type.Union([Type.Literal('manual'), Type.Literal('after_days')]),
+        purgeArchivedAfterDays: Type.Union([PositiveInteger, Type.Null()])
+    }, { additionalProperties: false }),
+    snapshot: Type.Object({ maxRuntimeEntities: PositiveInteger, pageSizeDefault: PositiveInteger, pageSizeMax: PositiveInteger }, { additionalProperties: false }),
+    sse: Type.Object({
+        heartbeatIntervalMs: Type.Integer({ minimum: 1000, maximum: 60000 }),
+        maxBufferedEvents: Type.Integer({ minimum: 16, maximum: 10000 }),
+        maxBufferedBytes: Type.Integer({ minimum: 65536, maximum: 16777216 })
+    }, { additionalProperties: false })
+}, { additionalProperties: false });

package/dist/contracts/adapter.d.ts

@@ -0,0 +1,28 @@
+import type { EffectScope } from './domain.js';
+export type AdapterPlatform = 'windows-x64' | 'linux-x64' | 'darwin-x64' | 'darwin-arm64';
+export type AdapterRuntime = 'node' | 'bun';
+export declare const ADAPTER_CONTRACT_VERSIONS: Readonly<{
+    concurrency: "1.0.0";
+    error: "1.0.0";
+    cancellation: "1.0.0";
+    timeout: "1.0.0";
+    recovery: "1.0.0";
+    conformance: "1.0.0";
+}>;
+export interface AdapterManifest {
+    readonly id: string;
+    readonly version: string;
+    readonly portVersions: Readonly<Record<string, string>>;
+    readonly capabilities: readonly string[];
+    readonly modelReferences: readonly string[];
+    readonly platforms: readonly AdapterPlatform[];
+    readonly runtimes: readonly AdapterRuntime[];
+    readonly effectScopes: readonly EffectScope[];
+    readonly concurrencyContractVersion: string;
+    readonly errorContractVersion: string;
+    readonly cancellationContractVersion: string;
+    readonly timeoutContractVersion: string;
+    readonly recoveryContractVersion: string;
+    readonly configSchemaDigest: string;
+    readonly conformanceTestVersion: string;
+}

package/dist/contracts/adapter.js

@@ -0,0 +1,8 @@
+export const ADAPTER_CONTRACT_VERSIONS = Object.freeze({
+    concurrency: '1.0.0',
+    error: '1.0.0',
+    cancellation: '1.0.0',
+    timeout: '1.0.0',
+    recovery: '1.0.0',
+    conformance: '1.0.0'
+});

package/dist/contracts/capability.d.ts

@@ -0,0 +1,41 @@
+import type { EffectScope, Json } from './domain.js';
+export interface CapabilityDefinition {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, Json>>;
+    readonly outputSchema?: Readonly<Record<string, Json>>;
+    readonly effect: EffectScope;
+    readonly adapterId: string;
+    readonly loadMode: 'eager' | 'deferred';
+    readonly outputLimitBytes: number;
+    readonly defaultAssignment?: 'all_new_agents' | 'configured' | 'none';
+    readonly kind?: 'tool' | 'command' | 'skill';
+    readonly promptText?: string;
+}
+export interface CapabilityInvocation {
+    readonly callId: string;
+    readonly projectId: string;
+    readonly agentId: string | null;
+    readonly capabilityId: string;
+    readonly arguments: Json;
+    readonly workspacePaths: readonly string[];
+    readonly workspaceId: string;
+    readonly fullAccess?: boolean;
+    readonly signal: AbortSignal;
+}
+export interface CapabilityOutput {
+    readonly content: Json;
+    readonly artifacts?: readonly ArtifactOutput[];
+    readonly outcome?: 'success' | 'failed';
+    readonly errorCode?: string;
+}
+export interface ArtifactOutput {
+    readonly name: string;
+    readonly mediaType: string;
+    readonly bytes: Uint8Array;
+}
+export interface CapabilityAdapter {
+    readonly id: string;
+    execute(invocation: CapabilityInvocation): Promise<CapabilityOutput>;
+}

package/dist/contracts/capability.js

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

package/dist/contracts/domain.d.ts

@@ -0,0 +1,61 @@
+export type Json = null | boolean | number | string | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export type RunState = 'READY' | 'RUNNING' | 'WAITING' | 'TERMINAL';
+export type StepState = 'RUNNING' | 'WAITING' | 'TERMINAL';
+export type AttemptState = 'PREPARED' | 'RUNNING' | 'TERMINAL';
+export type CallState = 'WAITING' | 'QUEUED' | 'RUNNING' | 'TERMINAL';
+export type Outcome = 'success' | 'failed' | 'cancelled' | 'interrupted';
+export type WaitReason = 'user_input' | 'policy_review';
+export type Policy = 'read_only' | 'workspace_write' | 'external' | 'ask' | 'auto_approve' | 'full_access';
+export type EffectScope = 'read_only' | 'workspace_write' | 'external' | 'full';
+export interface TrustedIngress {
+    readonly source: 'user';
+    readonly clientId: string;
+    readonly transport: 'http' | 'https';
+    readonly correlationId: string;
+}
+export interface EntityRef {
+    readonly type: string;
+    readonly id: string;
+}
+/**
+ * 07 `ChangedEntityRef`, plus the internal `type`/`id` the publisher already used. A subscriber
+ * needs `read_route` to know what to re-read and `owner_id` to refresh the owning view.
+ */
+export interface ChangedEntity extends EntityRef {
+    readonly entity_type: string;
+    readonly entity_id: string;
+    readonly owner_id: string | null;
+    readonly read_route: string;
+    readonly revision: number | null;
+    readonly change: 'created' | 'updated' | 'deleted';
+    /**
+     * 07 §4.2 invalidation scope, derived from Canonical State: what a subscriber must re-read, as
+     * opposed to which row changed. A Direct Call has no Agent, Task or Project, so these are omitted
+     * rather than fabricated.
+     */
+    readonly project_id?: string;
+    readonly task_id?: string;
+    readonly session_id?: string;
+    readonly agent_id?: string;
+}
+export interface ChangeSet {
+    readonly projectId: string;
+    readonly stateRevision: number;
+    readonly changes: readonly ChangedEntity[];
+}
+export interface Page<T> {
+    readonly items: readonly T[];
+    readonly nextCursor: string | null;
+    readonly collectionRevision: number;
+}
+export interface RuntimeEvent {
+    readonly id: string;
+    readonly projectId: string;
+    readonly stateRevision: number;
+    readonly metadataRevision: number;
+    readonly type: 'stream.delta' | 'entity.changed' | 'attention.required' | 'config.changed' | 'runtime.notice' | 'snapshot.required';
+    readonly payload: Json;
+    readonly occurredAt: string;
+}

package/dist/contracts/domain.js

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

package/dist/contracts/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adapter.js';
+export * from './capability.js';
+export * from './domain.js';
+export * from './model.js';
+export * from './ports.js';

package/dist/contracts/index.js

@@ -0,0 +1,5 @@
+export * from './adapter.js';
+export * from './capability.js';
+export * from './domain.js';
+export * from './model.js';
+export * from './ports.js';