@tangleai/outcomes 0.24.1

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# @tangleai/outcomes
+
+## 0.24.1
+
+### Patch Changes
+
+- @tangleai/agents@0.24.1
+  - @tangleai/config@0.24.1
+  - @tangleai/core@0.24.1
+  - @tangleai/memory@0.24.1
+  - @tangleai/models@0.24.1
+
+## 0.24.0
+
+### Minor Changes
+
+- Add the outcomes package for independently evidenced decisions, deterministic scoring, atomic confidence projection, bounded artifact refinement and explicitly approved promotion and rollback. The public operation contract, two-domain adapter kit and keyless example share the same scoped request receipts, one-use held-out gates, full head revision checks and interruption recovery.
+
+  The store adapter owns outcome records and memory changes in one SQLite transaction. The new pure confidence helper preserves fact fields; existing applyOutcome calls retain their original duplicate-citation and timestamp behavior and do not acquire a durable replay guarantee. No existing persisted memory format changes. Hosts opt into the new lifecycle, provide evidence and approval authority, and use a new artifact key for schema or policy changes. Scripted paired measurements and Node/Bun packed consumers qualify the mechanism; downstream domain integrations and automatic promotion remain separate work.
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/memory@0.24.0
+  - @tangleai/agents@0.24.0
+  - @tangleai/config@0.24.0
+  - @tangleai/core@0.24.0
+  - @tangleai/models@0.24.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joham (jklarenbeek@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,142 @@
+# @tangleai/outcomes
+
+Immutable evidenced decisions, deterministic scores, atomic memory projection,
+and explicitly approved domain artifacts. The host supplies scope, adapters,
+evidence resolver and authority. The package discovers no credentials and runs
+no scheduler.
+
+## Public lifecycle
+
+`await createOutcomeService(options)` returns `create`, `resolve`, `score`,
+`project`, `reflect`, `evaluate`, `approve`, `promote`, `rollback`, `reconcile`,
+`inspect`, `history` and `injectChecked`. Methods accept unknown JSON and return
+`{ok:true,value,replayed,writes}` or `{ok:false,issues:[{code,path,detail,retryable}]}`.
+Mutation envelopes carry `scopeId`, `artifactKey`, `requestKey`, normalized UTC
+`at`, and operation-specific `input`. Reads omit requestKey and at. Closed
+schemas and generated TypeScript contracts are exported at `./schemas/outcomes`
+and `./contracts`.
+
+- `create` records a pending decision, its exact input/output, cutoff and decision
+  times, adapter/configuration revisions, cited memories and used artifact id or
+  explicit static baseline. It returns `decisionId`.
+- `resolve` accepts evidence references. A trusted resolver supplies immutable
+  source bytes bound to decision id, scope, subject, issuer and observation time.
+  Their digests and timestamps are checked before a bounded snapshot is retained.
+  One resolution is accepted per decision; arrival lateness never rewrites the
+  observed time. It returns `resolutionId`.
+- `score` executes the pinned pure adapter and commits a score plus an authorized
+  projection intent. It returns `scoreId` and `projectionIntentId`.
+- `project` atomically applies confidence to sorted unique citations and writes a
+  terminal receipt. It returns `projectionReceiptId`, `applied`, `missing` and
+  `changedMemoryWrites`. Missing memories remain terminal skips; clamped unchanged
+  confidence is processed but not written. Fact timestamps and every other field
+  are preserved.
+- `reflect` stages a root (`mode:create`) or a child of the captured checked head
+  (`mode:evolve`). Roots supply a full payload; children use add/remove/replace/
+  test JSON Patch over the payload alone. Jaren's guarded refiner and patch engine
+  prepare detached candidates. Schema-valid candidates rejected by later semantic
+  or churn gates remain inspectable; oversized malformed outputs retain bounded
+  diagnostics. No-op children create no payload version.
+- `evaluate` obtains a host-registered held-out slot only after reserving it.
+  Candidate and paired baseline use identical cases and the registered scorer.
+  Eligibility requires complete coverage, strict positive mean utility, no domain
+  regression, valid bounds and registered call/cost limits. Case ids and content
+  cannot overlap training or previously consumed holdouts. Returns `evaluationId`,
+  `eligible`, `issues` and `caseReportId`.
+- `approve` needs the construction-time host principal's approval capability.
+  It binds action, candidate, evaluation, policy and the exact expected head.
+  Request JSON cannot grant authority. `promote` consumes that approval and CASes
+  both head version and revision. `rollback` requires a new action-specific
+  approval for a previously checked and active version. Both return
+  `activationEventId` and `head`; every real transition increments revision.
+- `injectChecked` verifies the exact scope/artifact head and returns its payload,
+  version, evaluation, activation and head references. It writes nothing. A
+  missing head is OUTC1004, and corrupt provenance is refused.
+
+A scope is the closed `{namespace,domain,subject}` object; `scopeIdOf` computes its
+canonical SHA-256 identity. Artifact keys are explicit host choices. Changing
+an established lineage's schema or bounds requires a new artifact key. Retained
+versions and audit records are immutable, including inactive and rolled-back
+versions.
+
+## Durability and replay
+
+`createMemoryOutcomeStore()` owns reference persistence and its `memories` view.
+`@tangleai/store`'s `createOutcomeStore(db)` owns the same records and the existing
+memories collection in one immediate Jaren transaction on Node or Bun SQLite.
+`createOutcomeStoreAdapter` is a trusted atomic persistence extension, not a wire
+write API. An unrelated ordinary MemoryStore cannot provide atomic receipts.
+
+Within a scope, an accepted request key binds the operation and complete canonical
+input, including supplied time. Exact completed replay returns its original
+business result with zero writes/calls. Changed input conflicts. A new key for a
+completed unique stage is OUTC1007, with an inspectable refusal receipt where
+storage is available. Known rollback is explicitly retryable. Resolution remains
+committed if scoring or projection fails. Lost acknowledgements reread stable
+receipts; unavailable recovery reports OUTC1017 rather than guessing.
+
+## Reference adapters and limits
+
+`./adapters/direction-delta` exports `createDirectionDeltaAdapter`: `{base}` plus
+`{offset}` predicts a finite number. Same sign and absolute error strictly below
+0.05 is success; same sign otherwise is partial; different sign is failure. Zero
+is nonnegative. Missing, non-finite and string numbers are refused.
+
+`./adapters/exact-match` exports `createExactMatchAdapter`: a token selects the
+longest case-sensitive prefix, or fallbackLabel. At most 16 unique nonblank
+prefixes are sorted by descending Unicode code-point length then code-point
+order. Exact case-sensitive label equality is success; otherwise failure. Common
+utility is success=1, partial=0.5, failure=0.
+
+Default policy bounds are 10 retained payload versions per scope/artifact,
+32,768 canonical UTF-8 payload bytes, 32 patch operations, 32 changed leaf paths
+and 8,192 UTF-8 reflection bytes. Empty containers and removed leaves count in
+churn. Capacity is reserved before a model dispatch; nothing silently evicts
+ancestry or rollback targets. Audit history is append-only and unbounded. Other
+input bounds are 16 evidence references/32,768 combined snapshot bytes, 128
+training scores or held-out cases, and 262,144 bytes per held-out registration or
+model proposal context. These are conservative defaults, not measured optima.
+
+## Optional model proposals
+
+`./proposer` exports `createStructuredOutcomeProposer` and
+`outcomeProposalComponents`. Register the exact prompt/response-schema revisions,
+then inject profile-resolution input, a role, fetch, clock, deadline factory and
+any credential/cache explicitly. The shipped config resolver, structured-output
+client, wire replay key and budget account supply one HTTP attempt, zero repairs,
+one concurrent call and a maximum 120-second deadline. A registered finite output
+ceiling of at most 8,192 tokens is required. Only training data, parent payload,
+domain schema and bounds reach the proposer; evaluation labels and authority do
+not. The ordinary package entry does not import this provider adapter.
+
+Dispatch and returned output are durably recorded before staging. Completed
+replay never calls the provider. Uncertain dispatch retains capacity and requires
+host-authorized `reconcile` with trusted retained-output or no-dispatch evidence.
+Reconciliation cannot approve or activate an artifact. Missing monetary usage is
+reported as unknown; a report hash is not a signature or authority credential.
+
+The [measured fixture](../../docs/OUTCOME_BENCHMARK.md) separates static decisions,
+checked scripted candidates, failed guards and unresolved outcomes. Its scripted
+improvement does not establish autonomous or real-domain learning.
+
+## Operations and adapter kit
+
+`createOutcomeContract` and `createOutcomeHandlers` expose all 13 operations
+through Jaren local/HTTP bindings. Use `validateOutput:'always'`; durable replay
+is owned by the outcome service. Principals omitted at construction cannot
+approve or reconcile. Scope access is checked before reads and replay.
+`inspect({id,includeLineage:true})` gives a bounded ancestry view; `history` pages
+50 records by default, at most 200, with a fixed upper sequence per cursor.
+
+See [the adapter kit](docs/ADAPTERS.md) for schemas, trust wiring, gates, errors,
+recovery and downstream ownership. Run `npm run outcomes:smoke` in the repository
+or `node examples/outcomes.ts --db /tmp/outcomes.sqlite` for the persistent
+two-domain walkthrough. `./schemas/contract` is the generated v1 wire document;
+`./contract` exports the compiled factory and handlers.
+
+Reservations are audited before host work. Lost reservation acknowledgement
+recovers an explicit retry; a trusted no-dispatch proof can reconcile a stranded
+reservation and fences its prior attempt. Histories retain these attempts even
+before a terminal operation receipt exists. The reference store is browser
+importable; SQLite remains in the separate store package and providers require
+explicit host injection.

package/docs/ADAPTERS.md

@@ -0,0 +1,215 @@
+# Outcome adapter kit
+
+`@tangleai/outcomes` records decisions, independently resolved outcomes, scores,
+projections, proposals, evaluations and explicit approvals. Hosts invoke these
+stages; the package installs no worker, scheduler or domain integration.
+
+Start with `node examples/outcomes.ts` in the repository. It runs both reference
+adapters without keys or network access. `node examples/outcomes.ts --db
+/tmp/outcomes.sqlite` uses the store adapter; repeating the command returns the
+same immutable ids with zero new writes or resolver calls. It stages a root and
+child in each domain, checks both, promotes both, then separately approves a
+rollback to the root. Times, request keys and fixtures are fixed for replay.
+
+## Register a domain and evidence authority
+
+An `OutcomeAdapter` supplies four closed JSON schemas (input, decision output,
+resolution and artifact), a schema/scorer revision identity, a static payload,
+a pure `interpret(input, payload)`, a pure `score(output, resolution)`, and
+semantic `validatePayload`. Optional normalization runs before artifact hashing.
+Schema digests and the complete adapter identity are checked at construction.
+Register immutable adapters; do not change their functions behind a revision.
+No submitted scorer program or submitted success/eligibility flag runs as code.
+
+The reference factories live at `@tangleai/outcomes/adapters/direction-delta`
+and `@tangleai/outcomes/adapters/exact-match`; their schemas have corresponding
+`./schemas/…` exports. Direction/delta requires finite `predicted` and `actual`
+numbers: equal sign and absolute error strictly below 0.05 is success; equal
+sign outside that tolerance is partial; different sign is failure. Zero has the
+nonnegative sign. Missing values never become zero. An offset artifact interprets
+`{base}` as `{predicted: base + offset}`, refusing non-finite results.
+Exact match compares case-sensitive labels. Its artifact has a fallback label
+and up to 16 unique prefix rules; the longest Unicode-code-point prefix wins.
+Normalization gives a stable rule ordering. No fuzzy match or label coercion
+changes a verdict. Utility is always success 1, partial 0.5, failure 0.
+
+Inject a trusted `EvidenceResolver` with a revision and `resolve(reference,
+scope)`. Wire commands carry only `{sourceId,digest}`. The resolver returns the
+retained `Source`: source id, decision id, scope id, subject, issuer, observed
+time, payload and digest. The digest is the canonical revision of all those
+fields except `digest`. Verify origin in your resolver before returning it.
+The service checks the requested digest, decision/scope/subject binding,
+chronology and domain schema and retains the exact snapshot. Decision evidence
+must name that decision; held-out and reconciliation evidence uses
+`decisionId:null`. A hash proves byte agreement, not external truth or authority.
+Arrival may be late; observed time must still follow decision time. One accepted
+resolution per decision is immutable in v1; source corrections need a separate
+future policy. At most 16 references and 32,768 combined snapshot bytes are read.
+
+## Bind the host before handling JSON
+
+Construct `createOutcomeService({store, scope, adapters, resolver,
+authorizeMemoryIds, ...})`. The closed scope is `{namespace,domain,subject}`.
+Every operation compares its `scopeId` with that host binding, including reads
+and replay. An id alone grants no access. `authorizeMemoryIds` returns an allowed
+boolean and immutable authorization revision for the sorted unique citations.
+Keep namespace-to-memory access enforcement in this host callback.
+
+Omitting `principal` denies both approval and reconciliation:
+
+```ts
+const service = await createOutcomeService({
+  store, scope, adapters: [adapter], resolver,
+  authorizeMemoryIds: async ids => ({
+    allowed: ids.every(id => authorizedIds.has(id)),
+    authorizationId,
+  }),
+});
+const handlers = createOutcomeHandlers({
+  resolveHost: () => ({ service, allowScope: id => id === service.scopeId }),
+});
+```
+
+For a trusted review service, supply an immutable principal with `id`,
+`authorityId` (a revision), `approve:true` and the explicitly granted
+`reconcile` capability. Never derive those booleans from request JSON or model
+text. HTTP hosts use their existing authentication to resolve `ctx.host` to a
+service and `allowScope` policy. Local clients have no custom host context;
+bind the host in the handler-factory closure. `OUTCOME_MODEL_OPERATIONS` excludes
+approve and reconcile. A model's service must also omit those capabilities;
+manually invoking their names then returns OUTC1012. Filtering a tool list alone
+is not an authorization boundary.
+
+`createOutcomeContract()` and `createOutcomeHandlers()` are exported from the
+root and `./contract`. `./schemas/contract` exports the generated portable
+contract. Each `outcomes.*` operation maps to one direct service method; wire
+`outcomes.inject` maps to `injectChecked`. Use Jaren local/HTTP bindings with
+`validateOutput:'always'`. Malformed input is JC2050 and broken handler/output
+is JC2070; a valid domain refusal remains `{ok:false,issues:[…]}` with OUTC
+codes. Transport idempotency is explicitly `none`. Durable request receipts,
+not a local client's annotation, implement business replay.
+
+## Stage and resolve a decision
+
+Every mutation takes `{scopeId,artifactKey,requestKey,at,input}`; reads omit the
+key and time. Times are normalized UTC strings with milliseconds. A request key
+is unique across operations within a scope and binds the entire canonical
+command, including time. Keep the same command to retry it. Completed exact
+replay returns its original value with `replayed:true,writes:0`; changed command
+bytes under that key fail OUTC1007. A new key repeating an already unique stage
+also fails OUTC1007 and may append its first refusal receipt.
+
+Call `create` with the decision-time input/output, pinned adapter and static
+payload, decision/cutoff/expected-resolution times, configuration, citations and
+`usedVersionId` (null for static). It returns `decisionId`. Checked decisions
+must reproduce their output from the current checked version. Deliver independent
+evidence to `resolve({decisionId,evidence,receivedAt})`; its `resolutionId`
+feeds `score({resolutionId})`. Score returns `scoreId` and
+`projectionIntentId`. It never resolves pending decisions or accepts a verdict.
+
+`project({scoreId})` returns `projectionReceiptId`, `applied`, `missing` and
+`changedMemoryWrites`. The same atomic owner must store memories and receipts:
+use `createMemoryOutcomeStore()` or `@tangleai/store`'s `createOutcomeStore(db)`.
+An unrelated four-method memory store cannot acquire this guarantee. Projection
+reads current confidence, applies shared arithmetic once per unique authorized
+id, and commits the memory changes and receipt together. It preserves fact time,
+text, evidence, embeddings and supersession fields. Missing memories are terminal
+counted skips; later restoration does not reapply a completed score. Empty
+citations complete with zero memory writes. The old memory `applyOutcome` remains
+a plain helper with its original duplicate and timestamp behavior.
+
+## Create, evolve, check, approve and restore
+
+`reflect` consumes prior independent `scoreIds`, a configuration and citations
+to those scores. Create mode requires a full root payload, null parent and no
+patch. Evolve requires the current checked parent, null payload and bounded JSON
+Patch operations. Jaren guarded refinement and JSON Patch are the generic engines.
+A no-op child returns a reflection with `versionId:null`. Valid but semantically
+ineligible proposals remain inactive, inspectable versions with issues.
+
+Defaults are 10 retained payload versions per scope/artifact, 32,768 canonical
+UTF-8 payload bytes, 32 patch operations, 32 changed leaf paths (union of before
+and after leaves, including array indices), and 8,192 reflection UTF-8 bytes.
+Version capacity is reserved before a model call. All valid staged, rejected and
+checked versions count; audit receipts have no total storage cap. Change policy
+or schema under a new artifact key rather than silently resetting a lineage.
+These are conservative registered bounds, not measured optimal values.
+
+The default proposer is the caller's explicitly scripted payload. Optional
+`createStructuredOutcomeProposer` at `./proposer` consumes a registered resolved
+configuration, injected fetch/key/clock/deadline, existing structured output,
+replay and budget seams. It requires one HTTP attempt, zero repair calls, one
+concurrent call, bounded output and at most 120 seconds per host deadline.
+Only prior training evidence and parent payload go to the model. The core reads
+no credentials or environment. Monetary cost is null when unavailable, not zero.
+Do not reuse another campaign's spend authorization.
+
+After freezing the candidate, the host's `evaluationSlot(slotId,versionId,scope)`
+returns an independently registered `EvaluationSlot`. It binds candidate,
+expected `{versionId,revision}`, training scores, evaluator and gate-policy
+revisions, held-out cases/sources and request/cost ceilings. The service checks
+these sources through the resolver and retains the registration before scoring.
+Training and held-out ids and content digests must be disjoint. A candidate and
+slot are each evaluated once; renamed/reused held-out content cannot become a
+fresh slot. Registrations and proposal training are bounded to 128 cases/scores
+and 262,144 canonical bytes.
+
+`evaluate({versionId,slotId})` returns evaluation/case-report ids, eligibility and
+issues. Eligibility requires complete nonempty paired coverage, no failures,
+strictly positive mean utility over the registered baseline, no domain loss,
+matching pinned revisions, semantic/size/churn gates and cost/request bounds.
+Failed candidates remain visible. These fixture gates do not establish practical
+improvement for your domain.
+
+A trusted principal invokes `approve` with action, version/evaluation ids,
+expected head pair and reason. Approval does not activate. `promote({approvalId})`
+rereads all dependencies and compares both version and monotonic revision in one
+transaction. The empty head is `{versionId:null,revision:0}`. Each real promotion
+or rollback increments revision; replay does not. `injectChecked` validates the
+full checked provenance and returns payload, head and version/evaluation/event
+ids. It performs no learning or writes; absent heads return OUTC1004 so hosts
+can explicitly use their static baseline.
+
+Rollback requires a fresh action-specific approval for a previously checked and
+active version in that artifact. Call `rollback({approvalId})`; all versions,
+failed candidates and activation history survive. A→B→A changes revision and
+invalidates approvals carrying A's old head pair. There is no unguarded setter.
+
+## Inspect and recover
+
+`inspect({id})` validates and returns the immutable typed record.
+`includeLineage:true` returns `{record,lineage}` with at most maxVersions ancestors
+for an artifact version; other kinds return an empty lineage. Missing records,
+corrupt bytes/edges and cycles are refusals. Follow typed ids for other stages.
+`history` defaults to 50 entries, caps page size at 200, and orders by per-scope
+sequence then id. Its cursor binds scope/artifact/filter revision and fixed upper
+sequence. Concurrent appends are outside subsequent pages of that snapshot.
+Cursors are pagination state, not authorization credentials. SQLite applies
+indexed scope/sequence predicates and SQL LIMIT; no whole collection is returned
+for history. The reference in-memory implementation scans its finite maps.
+
+Reservations append immutable audit events before external work. Lost reservation
+acknowledgements are recovered without stranding the key. A trusted no-dispatch
+proof can also reconcile an interrupted reservation and increments its attempt
+generation to fence the old worker. Known rolled-back storage failures are explicitly retryable. Already committed
+receipts recover lost acknowledgements. An external dispatch with unknown result
+is OUTC1017 and cannot automatically redispatch. A host with reconciliation
+capability supplies independent retained-output or no-dispatch proof binding
+attempt id, attempt number, input digest and the recorded wire request digest.
+Retained output resumes local staging; a proven no-dispatch result allows an
+explicit retry. Reconciliation does not approve or activate a proposal. A
+retryable or uncertain failure is not a completed result, and the service cannot
+promise a durable diagnostic while its storage is unavailable.
+
+## Consumer ownership
+
+| Consumer | Downstream responsibility |
+|---|---|
+| Milkyway | Forecast checkpoints, note schema, observation feeds and source-correction policy |
+| Trading | Realized return, fees, position/accounting identity and independent settlement evidence |
+| Repository evolution | Patch sandbox, repository state, execution permissions and independent checks |
+| Research | Evidence provenance, claim/state schema and resolution authority |
+| Desktop | Input collection, authentication, principal mapping, review controls and UI |
+
+None of these domain integrations ships in this kit. Reuse the lifecycle while
+keeping their schemas, trusted sources and deployment policies in their hosts.

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@tangleai/outcomes",
+  "version": "0.24.1",
+  "description": "Evidenced decisions, deterministic retrospective checks and explicitly approved artifact promotion",
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./contracts": {
+      "types": "./src/outcomes.contracts.gen.d.ts",
+      "import": "./src/outcomes.contracts.gen.js",
+      "default": "./src/outcomes.contracts.gen.js"
+    },
+    "./schemas/outcomes": "./schemas/outcomes.schema.json",
+    "./package.json": "./package.json",
+    "./adapters/direction-delta": {
+      "types": "./src/adapters/direction-delta.d.ts",
+      "import": "./src/adapters/direction-delta.js",
+      "default": "./src/adapters/direction-delta.js"
+    },
+    "./schemas/direction-delta": "./schemas/direction-delta.schema.json",
+    "./adapters/exact-match": {
+      "types": "./src/adapters/exact-match.d.ts",
+      "import": "./src/adapters/exact-match.js",
+      "default": "./src/adapters/exact-match.js"
+    },
+    "./schemas/exact-match": "./schemas/exact-match.schema.json",
+    "./proposer": {
+      "types": "./src/proposer.d.ts",
+      "import": "./src/proposer.js",
+      "default": "./src/proposer.js"
+    },
+    "./contract": {
+      "types": "./src/contract.d.ts",
+      "import": "./src/contract.js",
+      "default": "./src/contract.js"
+    },
+    "./schemas/contract": "./schemas/outcomes.contract.json"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@jarenjs/core": "0.86.0",
+    "@jarenjs/json": "0.86.0",
+    "@jarenjs/validate": "0.86.0",
+    "@tangleai/core": "^0.24.1",
+    "@tangleai/memory": "^0.24.1",
+    "@tangleai/models": "^0.24.1",
+    "@tangleai/agents": "^0.24.1",
+    "@tangleai/config": "^0.24.1",
+    "@jarenjs/contract": "0.86.0"
+  },
+  "private": false,
+  "types": "./src/index.d.ts",
+  "files": [
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "schemas/**/*.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "docs/**/*.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jklarenbeek/tangleai.git",
+    "directory": "packages/outcomes"
+  }
+}

package/schemas/direction-delta.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://tangleai.dev/outcomes/direction-delta",
+  "$ref": "#/$defs/artifact",
+  "$defs": {
+    "input": {
+      "type": "object",
+      "properties": {
+        "base": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "base"
+      ],
+      "additionalProperties": false
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "predicted": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "predicted"
+      ],
+      "additionalProperties": false
+    },
+    "resolution": {
+      "type": "object",
+      "properties": {
+        "actual": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "actual"
+      ],
+      "additionalProperties": false
+    },
+    "artifact": {
+      "type": "object",
+      "properties": {
+        "offset": {
+          "type": "number"
+        }
+      },
+      "required": [
+        "offset"
+      ],
+      "additionalProperties": false
+    }
+  }
+}

package/schemas/exact-match.schema.json

@@ -0,0 +1,88 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://tangleai.dev/outcomes/exact-match",
+  "$ref": "#/$defs/artifact",
+  "$defs": {
+    "input": {
+      "type": "object",
+      "properties": {
+        "token": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "\\S"
+        }
+      },
+      "required": [
+        "token"
+      ],
+      "additionalProperties": false
+    },
+    "output": {
+      "type": "object",
+      "properties": {
+        "label": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "\\S"
+        }
+      },
+      "required": [
+        "label"
+      ],
+      "additionalProperties": false
+    },
+    "resolution": {
+      "type": "object",
+      "properties": {
+        "label": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "\\S"
+        }
+      },
+      "required": [
+        "label"
+      ],
+      "additionalProperties": false
+    },
+    "artifact": {
+      "type": "object",
+      "properties": {
+        "fallbackLabel": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "\\S"
+        },
+        "rules": {
+          "type": "array",
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "properties": {
+              "prefix": {
+                "type": "string",
+                "minLength": 1,
+                "pattern": "\\S"
+              },
+              "label": {
+                "type": "string",
+                "minLength": 1,
+                "pattern": "\\S"
+              }
+            },
+            "required": [
+              "prefix",
+              "label"
+            ],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": [
+        "fallbackLabel",
+        "rules"
+      ],
+      "additionalProperties": false
+    }
+  }
+}