@tangleai/outcomes 0.24.1

package/src/refinement.d.ts

@@ -0,0 +1,40 @@
+import type { ServiceContext } from './service-context.ts';
+import type { OutcomeTransaction } from './store.ts';
+import type { OutcomeAdapter } from './adapters.ts';
+import type { Json, Policy, ReflectInput, ReflectCommand, Issue, Operation, Head } from './outcomes.contracts.gen.ts';
+/** A removed empty container and its new child leaves each count as changes. */
+export declare function changedLeafPaths(before: Json, after: Json): string[];
+export declare function preparePayload(adapter: OutcomeAdapter, policy: Policy, previous: Json, raw: ReflectInput): {
+    payload: Json;
+    issues: Issue[];
+    changed: string[];
+    noOp: boolean;
+};
+export declare function trainingRecords(tx: OutcomeTransaction, context: ServiceContext, artifactKey: string, ids: string[], at: string): Promise<{
+    score: import("./outcomes.contracts.gen.ts").Score;
+    decision: import("./outcomes.contracts.gen.ts").Decision;
+    resolution: import("./outcomes.contracts.gen.ts").Resolution;
+    contentDigest: string;
+}[]>;
+export declare function reflectionContext(context: ServiceContext, c: ReflectCommand, capturedHead?: Head): Promise<{
+    training: {
+        score: import("./outcomes.contracts.gen.ts").Score;
+        decision: import("./outcomes.contracts.gen.ts").Decision;
+        resolution: import("./outcomes.contracts.gen.ts").Resolution;
+        contentDigest: string;
+    }[];
+    adapter: OutcomeAdapter;
+    head: Head;
+    previous: Json;
+}>;
+export declare function commitReflection(tx: OutcomeTransaction, context: ServiceContext, c: ReflectCommand, op: Operation, data: Awaited<ReturnType<typeof reflectionContext>>, input: ReflectInput): Promise<{
+    reflectionId: string;
+    versionId: null;
+    noOp: boolean;
+    issues: Json;
+} | {
+    reflectionId: string;
+    versionId: string;
+    noOp: boolean;
+    issues: Json;
+}>;

package/src/refinement.js

@@ -0,0 +1,167 @@
+/** Bounded payload plans over Jaren's generic guarded engine and JSON Patch. */
+import { checkedHead } from "./promotion.js";
+import { createGuardedRefiner } from '@jarenjs/core/guarded';
+import { cloneJson, equalsJson } from '@jarenjs/core/object';
+import { applyJSONPatch } from '@jarenjs/json/patch';
+import { parseJSONPointer, encodeJSONPointerSegment } from '@jarenjs/json/pointer';
+import { domainValidator, scoreUtility } from "./domain.js";
+import { checkShape, jsonBytes } from "./schema.js";
+import { outcomeRevision } from "./identity.js";
+import { issue, reject, OutcomeRefusal } from "./errors.js";
+import { headFor, semantic, putRecord, unique } from "./persistence.js";
+import { assertHead } from "./transitions.js";
+import { recordOf, seal, asJson } from "./service-context.js";
+const forbidden = new Set(['__proto__', 'prototype', 'constructor']);
+const envelope = new Set(['scope', 'scopeId', 'artifactKey', 'adapter', 'payloadSchema', 'schemaVersion', 'policy', 'policyId', 'parentVersionId', 'approval', 'evaluation', 'evidence', 'id', 'recordedAt']);
+function leaves(value, path = '', output = new Map()) {
+    if (value !== null && typeof value === 'object' && Object.keys(value).length) {
+        for (const [key, child] of Object.entries(value))
+            leaves(child, path + '/' + encodeJSONPointerSegment(key), output);
+    }
+    else
+        output.set(path, value);
+    return output;
+}
+/** A removed empty container and its new child leaves each count as changes. */
+export function changedLeafPaths(before, after) {
+    const a = leaves(before), b = leaves(after);
+    return [...new Set([...a.keys(), ...b.keys()])].filter(path => !a.has(path) || !b.has(path) || !equalsJson(a.get(path), b.get(path))).sort();
+}
+function payloadPaths(value) {
+    if (value !== null && typeof value === 'object')
+        for (const [key, child] of Object.entries(value)) {
+            if (forbidden.has(key))
+                reject('OUTC1009', 'Prototype-related payload members are forbidden.');
+            payloadPaths(child);
+        }
+}
+export function preparePayload(adapter, policy, previous, raw) {
+    const shape = domainValidator(adapter.schemas.artifact);
+    const guarded = createGuardedRefiner({
+        read: async () => previous,
+        validateProposal(value) {
+            const input = checkShape('reflectInput', value);
+            if (input.patch.length > policy.maxOperations)
+                reject('OUTC1009', 'Patch operation limit exceeded.');
+            if (new TextEncoder().encode(input.text).length > policy.maxReflectionBytes)
+                reject('OUTC1009', 'Reflection UTF-8 byte limit exceeded.');
+            if (input.mode === 'create' && input.patch.length)
+                reject('OUTC1009', 'Root creation requires a payload, without a patch.');
+            if (input.mode === 'evolve' && input.payload !== null)
+                reject('OUTC1009', 'Evolution requires a patch, with payload null.');
+            for (const patch of input.patch) {
+                let path;
+                try {
+                    path = parseJSONPointer(patch.path);
+                }
+                catch {
+                    reject('OUTC1009', 'Invalid JSON Pointer.');
+                }
+                if (path.some(p => forbidden.has(p)) || envelope.has(path[0]))
+                    reject('OUTC1009', 'Patch paths may address only the domain payload.');
+            }
+            return true;
+        },
+        apply(document, input) { return input.mode === 'create' ? input.payload : applyJSONPatch(document, input.patch); },
+        applyFailure: () => issue('OUTC1009', 'The patch does not apply to the captured payload.'),
+        validateCandidate(value) {
+            const payload = shape(value);
+            payloadPaths(payload);
+            if (jsonBytes(payload) > policy.maxPayloadBytes)
+                reject('OUTC1009', 'Canonical payload UTF-8 byte limit exceeded.');
+            return true;
+        },
+        planCommit(value, before) {
+            const payload = shape(adapter.normalizePayload ? adapter.normalizePayload(value) : value);
+            payloadPaths(payload);
+            if (jsonBytes(payload) > policy.maxPayloadBytes)
+                reject('OUTC1009', 'Normalized payload UTF-8 byte limit exceeded.');
+            const changed = changedLeafPaths(before, payload);
+            const issues = adapter.validatePayload(payload).map(i => checkShape('issue', i));
+            if (changed.length > policy.maxChangedLeaves)
+                issues.push(issue('OUTC1009', 'Changed leaf path limit exceeded.'));
+            return { payload, issues, changed, noOp: raw.mode === 'evolve' && equalsJson(before, payload) };
+        },
+        commit: async () => { throw new TypeError('Payload preparation never commits through the generic engine.'); },
+    });
+    const prepared = guarded.prepare(previous, raw);
+    if (!prepared.valid || !prepared.plan) {
+        const errors = prepared.errors;
+        const known = errors[0]?.code;
+        // Guarded catches private exceptions; preserve the outcome code without model text.
+        const code = known && /^OUTC10(0[1-9]|1[0-9])$/.test(known) ? known : 'OUTC1009';
+        throw new OutcomeRefusal([issue(code, 'Payload preparation refused the proposal.')]);
+    }
+    return prepared.plan;
+}
+export async function trainingRecords(tx, context, artifactKey, ids, at) {
+    if (!ids.length || new Set(ids).size !== ids.length)
+        reject('OUTC1001', 'Training score ids must be nonempty and unique.');
+    const training = [];
+    for (const id of [...ids].sort()) {
+        const score = await recordOf(tx, id, context.scopeId, artifactKey, 'score');
+        const decision = await recordOf(tx, score.decisionId, context.scopeId, artifactKey, 'decision');
+        const resolution = await recordOf(tx, score.resolutionId, context.scopeId, artifactKey, 'resolution');
+        const { adapter, domain } = context.adapter(decision.adapter);
+        const verdict = adapter.score(domain.output(decision.output), domain.resolution(resolution.payload));
+        if (resolution.decisionId !== decision.id || score.scorerRevision !== adapter.identity.scorerRevision || score.utility !== scoreUtility(verdict.outcome) || score.outcome !== verdict.outcome || score.recordedAt > at)
+            reject('OUTC1002', 'Training evidence or score binding differs.');
+        training.push({ score, decision, resolution, contentDigest: await outcomeRevision({ domain: decision.scope.domain, input: decision.input, outcome: resolution.payload }) });
+    }
+    if (new Set(training.map(t => t.decision.adapter.revision)).size !== 1)
+        reject('OUTC1008', 'One artifact lineage has one registered adapter revision.');
+    return training;
+}
+export async function reflectionContext(context, c, capturedHead) {
+    return context.atomic().transaction(async (tx) => {
+        const training = await trainingRecords(tx, context, c.artifactKey, c.input.scoreIds, c.at);
+        const adapter = context.adapter(training[0].decision.adapter).adapter;
+        const head = capturedHead ?? await headFor(tx, c.scopeId, c.artifactKey);
+        if (c.input.mode === 'create' && (head.versionId !== null || c.input.parentVersionId !== null))
+            reject('OUTC1013', 'A root can only be staged before a checked head exists.');
+        if (c.input.mode === 'evolve' && (head.versionId === null || head.versionId !== c.input.parentVersionId))
+            reject('OUTC1013', 'Evolution requires the current checked parent.');
+        if (head.versionId !== null && !capturedHead)
+            await checkedHead(tx, context, c.artifactKey);
+        let parent = null;
+        if (head.versionId !== null)
+            parent = await recordOf(tx, head.versionId, c.scopeId, c.artifactKey, 'artifactVersion');
+        const lineage = await semantic(tx, c.scopeId, 'lineage', c.artifactKey);
+        if (lineage) {
+            const root = await recordOf(tx, lineage, c.scopeId, c.artifactKey, 'artifactVersion');
+            if (root.policyId !== context.policyId || !equalsJson(root.adapter, adapter.identity))
+                reject('OUTC1008', 'A schema or policy change requires a new artifact key.');
+        }
+        if (parent && (parent.policyId !== context.policyId || !equalsJson(parent.adapter, adapter.identity)))
+            reject('OUTC1008', 'Parent policy or adapter differs.');
+        return { training, adapter, head, previous: parent?.payload ?? adapter.staticPayload };
+    });
+}
+export async function commitReflection(tx, context, c, op, data, input) {
+    const plan = preparePayload(data.adapter, context.policy, data.previous, input);
+    const scores = [...input.scoreIds].sort();
+    if (!equalsJson(scores, data.training.map(t => t.score.id)) || new Set(input.citations).size !== input.citations.length || input.citations.some(id => !scores.includes(id)))
+        reject('OUTC1006', 'Reflection citations must name the provided verified training scores.');
+    const current = await headFor(tx, c.scopeId, c.artifactKey);
+    try {
+        assertHead(current, data.head);
+    }
+    catch {
+        plan.issues.push(issue('OUTC1013', 'The captured parent head changed during proposal preparation.'));
+    }
+    const lineage = await semantic(tx, c.scopeId, 'lineage', c.artifactKey);
+    if (lineage) {
+        const root = await recordOf(tx, lineage, c.scopeId, c.artifactKey, 'artifactVersion');
+        if (root.policyId !== context.policyId || !equalsJson(root.adapter, data.adapter.identity))
+            reject('OUTC1008', 'Lineage policy or adapter changed.');
+    }
+    const reflection = await seal('reflection', c.scopeId, c.artifactKey, c.at, { scoreIds: scores, parentVersionId: input.parentVersionId, configuration: input.configuration, text: input.text, citations: [...input.citations].sort(), attemptId: op.id });
+    await putRecord(tx, reflection);
+    if (plan.noOp)
+        return { reflectionId: reflection.id, versionId: null, noOp: true, issues: asJson(plan.issues) };
+    const version = await seal('artifactVersion', c.scopeId, c.artifactKey, c.at, { parentVersionId: input.parentVersionId, expectedHead: data.head, payload: plan.payload, payloadSchema: data.adapter.identity.artifactSchema, adapter: data.adapter.identity, reflectionId: reflection.id, mode: input.mode, policyId: context.policyId, policy: context.policy, issues: plan.issues });
+    await putRecord(tx, version);
+    if (!lineage)
+        await unique(tx, c.scopeId, 'lineage', c.artifactKey, version.id);
+    return { reflectionId: reflection.id, versionId: version.id, noOp: false, issues: asJson(plan.issues) };
+}

package/src/resolution.d.ts

@@ -0,0 +1,12 @@
+import type { ServiceContext } from './service-context.ts';
+import type { OutcomeTransaction } from './store.ts';
+import type { Source, SourceRef, ResolveCommand } from './outcomes.contracts.gen.ts';
+export declare function verifiedSource(context: ServiceContext, reference: SourceRef, earliest: string, receivedAt: string): Promise<Source>;
+export declare function prepareResolution(context: ServiceContext, c: ResolveCommand): Promise<{
+    decision: import("./outcomes.contracts.gen.ts").Decision;
+    sources: Source[];
+    payload: import("./outcomes.contracts.gen.ts").Json;
+}>;
+export declare function commitResolution(tx: OutcomeTransaction, context: ServiceContext, c: ResolveCommand, data: Awaited<ReturnType<typeof prepareResolution>>): Promise<{
+    resolutionId: string;
+}>;

package/src/resolution.js

@@ -0,0 +1,62 @@
+/** Accepted evidence is a verified host snapshot, independent of scoring. */
+import { equalsJson } from '@jarenjs/core/object';
+import { checkShape, checkTime, jsonBytes } from "./schema.js";
+import { outcomeRevision } from "./identity.js";
+import { reject } from "./errors.js";
+import { putRecord, unique } from "./persistence.js";
+import { recordOf, requireNew, seal } from "./service-context.js";
+export async function verifiedSource(context, reference, earliest, receivedAt) {
+    const loaded = await context.resolver.resolve(reference, context.scope);
+    if (!loaded)
+        reject('OUTC1006', 'The trusted resolver cannot supply the pinned source.');
+    const source = checkShape('source', loaded);
+    if (source.scopeId !== context.scopeId || source.subject !== context.scope.subject)
+        reject('OUTC1003', 'Evidence belongs to another scope or subject.');
+    const { digest, ...bytes } = source;
+    if (source.sourceId !== reference.sourceId || digest !== reference.digest || await outcomeRevision(bytes) !== digest)
+        reject('OUTC1006', 'Evidence bytes differ from the pinned source.');
+    checkTime(source.observedAt);
+    checkTime(receivedAt);
+    if (source.observedAt < earliest || receivedAt < source.observedAt)
+        reject('OUTC1006', 'Evidence observation is outside the accepted time interval.');
+    if (jsonBytes(source) > 32768)
+        reject('OUTC1006', 'Evidence snapshot exceeds 32,768 canonical UTF-8 bytes.');
+    return source;
+}
+export async function prepareResolution(context, c) {
+    const decision = await context.atomic().transaction(async (tx) => {
+        await requireNew(tx, c.scopeId, 'resolution', c.input.decisionId);
+        return recordOf(tx, c.input.decisionId, c.scopeId, c.artifactKey, 'decision');
+    });
+    const { domain } = context.adapter(decision.adapter);
+    if (new Set(c.input.evidence.map(r => r.sourceId)).size !== c.input.evidence.length)
+        reject('OUTC1001', 'Evidence references must be unique.');
+    if (c.at < c.input.receivedAt)
+        reject('OUTC1006', 'Receipt time precedes evidence arrival.');
+    const sources = [];
+    for (const reference of c.input.evidence) {
+        const source = await verifiedSource(context, reference, decision.decidedAt, c.input.receivedAt);
+        if (source.decisionId !== decision.id)
+            reject('OUTC1003', 'Evidence was observed for another decision.');
+        sources.push(source);
+    }
+    const payload = domain.resolution(sources[0].payload);
+    if (jsonBytes(sources) > 32768)
+        reject('OUTC1006', 'Combined evidence snapshots exceed 32,768 canonical UTF-8 bytes.');
+    for (const source of sources)
+        if (!equalsJson(domain.resolution(source.payload), payload))
+            reject('OUTC1006', 'Sources disagree on the accepted outcome.');
+    return { decision, sources: sources.sort((a, b) => a.sourceId < b.sourceId ? -1 : 1), payload };
+}
+export async function commitResolution(tx, context, c, data) {
+    await requireNew(tx, c.scopeId, 'resolution', c.input.decisionId);
+    const resolution = await seal('resolution', c.scopeId, c.artifactKey, c.at, {
+        decisionId: data.decision.id, resolverRevision: context.resolverRevision, sources: data.sources,
+        payload: data.payload, receivedAt: c.input.receivedAt,
+        late: data.decision.expectedResolutionAt === null ? null : c.input.receivedAt > data.decision.expectedResolutionAt,
+        resolutionSchema: data.decision.adapter.resolutionSchema,
+    });
+    await putRecord(tx, resolution);
+    await unique(tx, c.scopeId, 'resolution', data.decision.id, resolution.id);
+    return { resolutionId: resolution.id };
+}

package/src/schema.d.ts

@@ -0,0 +1,8 @@
+import outcomesSchema from '../schemas/outcomes.schema.json' with { type: "json" };
+import type { Json, OutcomeRecord, Policy } from './outcomes.contracts.gen.ts';
+export { outcomesSchema };
+export declare function checkShape<T>(name: string, value: unknown): T;
+export declare function checkTime(value: string): string;
+export declare const DEFAULT_OUTCOME_POLICY: Readonly<Policy>;
+export declare function jsonBytes(value: Json): number;
+export declare function checkRecordShape(value: unknown): OutcomeRecord;

package/src/schema.js

@@ -0,0 +1,34 @@
+/** One schema authority. Canonicalization rejects non-JSON input before cloning. */
+import { JarenValidator } from '@jarenjs/validate';
+import { canonicalizeJson } from '@jarenjs/json/canonical';
+import { cloneJson, deepFreeze } from '@jarenjs/core/object';
+import outcomesSchema from '../schemas/outcomes.schema.json' with { type: 'json' };
+import { reject } from "./errors.js";
+export { outcomesSchema };
+const validators = new Map();
+export function checkShape(name, value) {
+    try {
+        canonicalizeJson(value);
+    }
+    catch {
+        reject('OUTC1001', 'Only finite JSON data is accepted.');
+    }
+    let validate = validators.get(name);
+    if (!validate) {
+        const v = new JarenValidator({ skipErrors: false, collectErrors: true, unknownFormats: 'ignore' });
+        validate = v.compile({ $defs: outcomesSchema.$defs, $ref: `#/$defs/${name}` });
+        validators.set(name, validate);
+    }
+    const result = validate(value);
+    if (!result.valid)
+        reject('OUTC1001', `Invalid ${name} data.`);
+    return deepFreeze(cloneJson(value));
+}
+export function checkTime(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString() !== value)
+        reject('OUTC1001', 'Expected a valid normalized UTC instant.');
+    return value;
+}
+export const DEFAULT_OUTCOME_POLICY = Object.freeze({ maxVersions: 10, maxPayloadBytes: 32768, maxOperations: 32, maxChangedLeaves: 32, maxReflectionBytes: 8192 });
+export function jsonBytes(value) { return new TextEncoder().encode(canonicalizeJson(value)).length; }
+export function checkRecordShape(value) { const r = checkShape('outcomeRecord', value); checkTime(r.recordedAt); return r; }

package/src/scoring.d.ts

@@ -0,0 +1,15 @@
+import type { ServiceContext } from './service-context.ts';
+import type { OutcomeTransaction } from './store.ts';
+import type { ScoreCommand } from './outcomes.contracts.gen.ts';
+export declare function prepareScore(context: ServiceContext, c: ScoreCommand): Promise<{
+    resolution: import("./outcomes.contracts.gen.ts").Resolution;
+    decision: import("./outcomes.contracts.gen.ts").Decision;
+    outcome: "success" | "failure" | "partial";
+    diagnostics: import("./outcomes.contracts.gen.ts").Json;
+    memoryIds: string[];
+    authorizationId: string;
+}>;
+export declare function commitScore(tx: OutcomeTransaction, context: ServiceContext, c: ScoreCommand, data: Awaited<ReturnType<typeof prepareScore>>): Promise<{
+    scoreId: string;
+    projectionIntentId: string;
+}>;

package/src/scoring.js

@@ -0,0 +1,37 @@
+/** Scores commit with a projection intent; projection is independently retryable. */
+import { checkShape } from "./schema.js";
+import { outcomeRevision } from "./identity.js";
+import { scoreUtility } from "./domain.js";
+import { reject } from "./errors.js";
+import { putRecord, unique } from "./persistence.js";
+import { recordOf, requireNew, seal, asJson } from "./service-context.js";
+export async function prepareScore(context, c) {
+    const { resolution, decision } = await context.atomic().transaction(async (tx) => {
+        const resolution = await recordOf(tx, c.input.resolutionId, c.scopeId, c.artifactKey, 'resolution');
+        await requireNew(tx, c.scopeId, 'score', resolution.decisionId);
+        const decision = await recordOf(tx, resolution.decisionId, c.scopeId, c.artifactKey, 'decision');
+        return { resolution, decision };
+    });
+    const { adapter, domain } = context.adapter(decision.adapter);
+    if (resolution.resolutionSchema !== adapter.identity.resolutionSchema || c.at < resolution.recordedAt)
+        reject('OUTC1008', 'Score schema or chronology differs from its resolution.');
+    const answer = adapter.score(domain.output(decision.output), domain.resolution(resolution.payload));
+    const outcome = checkShape('category', answer.outcome);
+    const diagnostics = asJson({ adapter: answer.diagnostics, inputDigest: await outcomeRevision(decision.input), outputDigest: await outcomeRevision(decision.output), resolutionDigest: await outcomeRevision(resolution.payload) });
+    const memoryIds = [...new Set(decision.memoryIds)].sort();
+    const authorizationId = await context.authorization(memoryIds);
+    return { resolution, decision, outcome, diagnostics, memoryIds, authorizationId };
+}
+export async function commitScore(tx, context, c, data) {
+    await requireNew(tx, c.scopeId, 'score', data.decision.id);
+    const score = await seal('score', c.scopeId, c.artifactKey, c.at, {
+        decisionId: data.decision.id, resolutionId: data.resolution.id, scorerRevision: data.decision.adapter.scorerRevision,
+        outcome: data.outcome, utility: scoreUtility(data.outcome), diagnostics: data.diagnostics, policyId: context.confidencePolicyId,
+    });
+    const intent = await seal('projectionIntent', c.scopeId, c.artifactKey, c.at, { scoreId: score.id, memoryIds: data.memoryIds, authorizationId: data.authorizationId, policyId: context.confidencePolicyId });
+    await putRecord(tx, score);
+    await putRecord(tx, intent);
+    await unique(tx, c.scopeId, 'score', data.decision.id, score.id);
+    await unique(tx, c.scopeId, 'projectionIntent', score.id, intent.id);
+    return { scoreId: score.id, projectionIntentId: intent.id };
+}

package/src/service-context.d.ts

@@ -0,0 +1,50 @@
+import type { OutcomeStore, OutcomeTransaction } from './store.ts';
+import type { OutcomeAdapter, OutcomeHost, OutcomePrincipal } from './adapters.ts';
+import type { AdapterIdentity, ConfidencePolicy, Json, OutcomeRecord, Policy, Configuration } from './outcomes.contracts.gen.ts';
+export interface OutcomeServiceOptions extends OutcomeHost {
+    store: OutcomeStore;
+    policy?: Policy;
+    confidencePolicy?: ConfidencePolicy;
+}
+export declare const asJson: (value: unknown) => Json;
+export declare function makeContext(options: OutcomeServiceOptions): Promise<{
+    principal: Readonly<OutcomePrincipal>;
+    scope: import("./outcomes.contracts.gen.ts").Scope;
+    scopeId: string;
+    policy: Policy;
+    policyId: string;
+    confidencePolicy: ConfidencePolicy;
+    confidencePolicyId: string;
+    resolverRevision: string;
+    gatePolicyId: string;
+    configuration(configuration: Configuration): Promise<import("@tangleai/config").RunIdentity | null>;
+    atomic(): import("./store.ts").OutcomePersistence;
+    adapter(identity: AdapterIdentity): {
+        adapter: OutcomeAdapter;
+        domain: {
+            input: (value: unknown) => Json;
+            output: (value: unknown) => Json;
+            resolution: (value: unknown) => Json;
+            artifact(value: unknown): Json;
+        };
+    };
+    authorization(ids: readonly string[]): Promise<string>;
+    store: OutcomeStore;
+    adapters: readonly OutcomeAdapter[];
+    resolver: import("./adapters.ts").EvidenceResolver;
+    authorizeMemoryIds(ids: readonly string[], scope: import("./outcomes.contracts.gen.ts").Scope): Promise<{
+        allowed: boolean;
+        authorizationId: string;
+    }>;
+    evaluationSlot?(slotId: string, versionId: string, scope: import("./outcomes.contracts.gen.ts").Scope): Promise<import("./outcomes.contracts.gen.ts").EvaluationSlot | undefined>;
+    proposer?: import("./adapters.ts").OutcomeProposer;
+    resolveConfiguration?(identityId: string): Promise<import("@tangleai/config").RunIdentity | undefined>;
+}>;
+export type ServiceContext = Awaited<ReturnType<typeof makeContext>>;
+export declare function recordOf<K extends OutcomeRecord['kind']>(tx: OutcomeTransaction, id: string, scopeId: string, artifactKey: string, kind: K): Promise<Extract<OutcomeRecord, {
+    kind: K;
+}>>;
+export declare const seal: <K extends OutcomeRecord["kind"]>(kind: K, scopeId: string, artifactKey: string, at: string, data: object) => Promise<Extract<OutcomeRecord, {
+    kind: K;
+}>>;
+export declare function requireNew(tx: OutcomeTransaction, scopeId: string, kind: string, key: Json): Promise<void>;

package/src/service-context.js

@@ -0,0 +1,81 @@
+/** A service binds trusted host capabilities before accepting request JSON. */
+import { equalsJson } from '@jarenjs/core/object';
+import { DEFAULT_OUTCOME_OPTIONS } from '@tangleai/memory/outcome';
+import { checkShape, DEFAULT_OUTCOME_POLICY } from "./schema.js";
+import { outcomeRevision, scopeIdOf, sealRecord } from "./identity.js";
+import { checkedAdapter } from "./domain.js";
+import { reject } from "./errors.js";
+import { readRecord, semantic } from "./persistence.js";
+import { persistenceFor } from "./store.js";
+import { outcomeGatePolicyId } from "./evaluation.js";
+import { validateRunIdentity, identityIdOf } from '@tangleai/config';
+export const asJson = (value) => checkShape('json', value);
+export async function makeContext(options) {
+    const scope = checkShape('scope', options.scope), scopeId = await scopeIdOf(scope);
+    const policy = checkShape('policy', options.policy ?? DEFAULT_OUTCOME_POLICY);
+    const confidencePolicy = checkShape('confidencePolicy', options.confidencePolicy ?? DEFAULT_OUTCOME_OPTIONS);
+    if (confidencePolicy.minConfidence > confidencePolicy.maxConfidence)
+        throw new TypeError('Confidence minimum exceeds maximum.');
+    const confidencePolicyId = await outcomeRevision(confidencePolicy), policyId = await outcomeRevision(policy);
+    const principal = Object.freeze(checkShape('principal', options.principal ?? { id: 'unprivileged', authorityId: await outcomeRevision({ authority: 'none' }), approve: false, reconcile: false }));
+    const registry = new Map();
+    for (const adapter of options.adapters) {
+        const identity = checkShape('adapterIdentity', adapter.identity);
+        for (const key of ['input', 'output', 'resolution', 'artifact']) {
+            if (await outcomeRevision(adapter.schemas[key]) !== identity[`${key}Schema`])
+                throw new TypeError('Adapter schema identity differs.');
+        }
+        if (registry.has(identity.revision))
+            throw new TypeError('Duplicate adapter revision.');
+        registry.set(identity.revision, adapter);
+    }
+    const resolverRevision = checkShape('hash', options.resolver.revision);
+    return {
+        ...options, principal, scope, scopeId, policy, policyId, confidencePolicy, confidencePolicyId, resolverRevision,
+        gatePolicyId: await outcomeGatePolicyId(asJson(policy)),
+        async configuration(configuration) {
+            if (configuration.kind === 'scripted')
+                return null;
+            const identity = options.proposer?.identity.identityId === configuration.identityId ? options.proposer.identity : await options.resolveConfiguration?.(configuration.identityId);
+            const checked = validateRunIdentity(identity);
+            if (!checked.ok)
+                reject('OUTC1008', 'The model configuration identity is not registered.');
+            const { identityId, ...payload } = checked.value;
+            if (identityId !== configuration.identityId || await identityIdOf(payload) !== identityId)
+                reject('OUTC1008', 'Model configuration bytes differ from their identity.');
+            return checked.value;
+        },
+        atomic() {
+            try {
+                return persistenceFor(options.store);
+            }
+            catch {
+                reject('OUTC1018', 'An outcome store must own memory and receipts atomically.');
+            }
+        },
+        adapter(identity) {
+            const adapter = registry.get(identity.revision);
+            if (!adapter || !equalsJson(adapter.identity, identity))
+                reject('OUTC1008', 'The pinned adapter revision is not registered.');
+            return { adapter, domain: checkedAdapter(adapter) };
+        },
+        async authorization(ids) {
+            const answer = await options.authorizeMemoryIds(ids, scope);
+            if (!answer.allowed)
+                reject('OUTC1003', 'The host refused memory citations for this scope.');
+            return checkShape('hash', answer.authorizationId);
+        },
+    };
+}
+export async function recordOf(tx, id, scopeId, artifactKey, kind) {
+    const record = await readRecord(tx, id, scopeId, artifactKey);
+    if (record.kind !== kind)
+        reject('OUTC1005', `This transition requires a ${kind} record.`);
+    return record;
+}
+export const seal = async (kind, scopeId, artifactKey, at, data) => await sealRecord({ ...data, schemaVersion: 1, kind, scopeId, artifactKey, recordedAt: at });
+export async function requireNew(tx, scopeId, kind, key) {
+    const id = await semantic(tx, scopeId, kind, key);
+    if (id)
+        reject('OUTC1007', `The ${kind} stage is already complete: ${id}.`);
+}

package/src/service.d.ts

@@ -0,0 +1,22 @@
+import type { OutcomeServiceOptions } from './service-context.ts';
+import type { Result } from './outcomes.contracts.gen.ts';
+export type { OutcomeServiceOptions } from './service-context.ts';
+export declare function createOutcomeService(options: OutcomeServiceOptions): Promise<Readonly<{
+    scopeId: string;
+    policyId: string;
+    gatePolicyId: string;
+    create: (raw: unknown) => Promise<Result>;
+    resolve: (raw: unknown) => Promise<Result>;
+    score: (raw: unknown) => Promise<Result>;
+    project: (raw: unknown) => Promise<Result>;
+    reflect(raw: unknown): Promise<Result>;
+    evaluate: (raw: unknown) => Promise<Result>;
+    approve: (raw: unknown) => Promise<Result>;
+    promote: (raw: unknown) => Promise<Result>;
+    rollback: (raw: unknown) => Promise<Result>;
+    reconcile: (raw: unknown) => Promise<Result>;
+    injectChecked(raw: unknown): Promise<Result>;
+    history(raw: unknown): Promise<Result>;
+    inspect(raw: unknown): Promise<Result>;
+}>>;
+export type OutcomeService = Awaited<ReturnType<typeof createOutcomeService>>;