@vornicx/origin 0.1.0

package/dist/policy-KjPvxtus.d.ts

@@ -0,0 +1,605 @@
+import { z } from 'zod';
+
+/** Context types — the structured understanding of "the work around you". */
+interface FileRef {
+    /** Path relative to the scan root, POSIX-style. */
+    path: string;
+    /** Size in bytes. */
+    size: number;
+    /** Lowercased extension without the leading dot ("" if none). */
+    ext: string;
+    /** Human language/format name mapped from the extension, if known. */
+    language?: string;
+}
+interface ToolRef {
+    name: string;
+    description?: string;
+}
+interface Intent {
+    goal: string;
+    /** Action verbs detected in the goal (e.g. "deploy", "refactor"). */
+    verbs: string[];
+    /** Salient keywords from the goal. */
+    keywords: string[];
+}
+interface ContextBundle {
+    root: string;
+    files: FileRef[];
+    /** Language name → file count. */
+    languages: Record<string, number>;
+    tools: ToolRef[];
+    intent?: Intent;
+    /** True if the file scan hit the `maxFiles` cap. */
+    truncated: boolean;
+    scannedAt: string;
+}
+
+interface ScanOptions {
+    /** Directory to scan. Defaults to `process.cwd()`. */
+    root?: string;
+    /** Cap on files collected. Defaults to 2000. */
+    maxFiles?: number;
+    /** Tools available to the agent, surfaced in the bundle. */
+    tools?: ToolRef[];
+    /** A goal to parse into an `Intent`. */
+    goal?: string;
+    /** Ignore-file names to honor. Defaults to `.gitignore` + `.originignore`. */
+    ignoreFiles?: string[];
+}
+/**
+ * Understands the work around you: scans a workspace into a structured
+ * `ContextBundle` of files, languages, available tools, and parsed intent —
+ * honoring `.gitignore` / `.originignore`.
+ */
+declare class ContextEngine {
+    scan(options?: ScanOptions): Promise<ContextBundle>;
+}
+/** Parse a goal into an `Intent`: detected action verbs and salient keywords. */
+declare function parseIntent(goal: string): Intent;
+
+/**
+ * Atlas memory types.
+ *
+ * The record shape mirrors Apollo's memory model (`kind`, `importance` 1–5,
+ * `content`, `metadata`) so the same memory can back both Origin and Apollo.
+ */
+type MemoryKind = "note" | "chat" | "mission" | "fact" | "preference";
+interface MemoryRecord {
+    id: string;
+    content: string;
+    kind: MemoryKind;
+    /** 1 (incidental) … 5 (critical). */
+    importance: number;
+    source?: string;
+    metadata: Record<string, unknown>;
+    /** ISO-8601 timestamp. */
+    createdAt: string;
+    /** ISO-8601 timestamp. */
+    updatedAt: string;
+}
+interface RememberInput {
+    content: string;
+    kind?: MemoryKind;
+    importance?: number;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+interface RecallOptions {
+    limit?: number;
+    kind?: MemoryKind;
+    minImportance?: number;
+}
+interface RecallHit extends MemoryRecord {
+    /** Blended ranking score (relevance × importance × recency). */
+    score: number;
+}
+
+/**
+ * Persistence backend for Atlas memory. Implementations need only provide CRUD;
+ * ranking is done in `Memory`. A store MAY implement `recall` to push search down
+ * to the backend (e.g. SQL full-text), in which case `Memory` delegates to it.
+ */
+interface MemoryStore {
+    all(): Promise<MemoryRecord[]>;
+    get(id: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    recall?(query: string, options: RecallOptions): Promise<RecallHit[]>;
+}
+/** Ephemeral, in-process store. The default when no persistence is configured. */
+declare class InMemoryStore implements MemoryStore {
+    private readonly records;
+    all(): Promise<MemoryRecord[]>;
+    get(id: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+
+interface MemoryOptions {
+    store?: MemoryStore;
+    /** Injectable clock (tests). Defaults to `() => new Date()`. */
+    now?: () => Date;
+}
+/**
+ * Atlas — Origin's persistent memory. Remembers notes, facts, preferences,
+ * decisions and chat across sessions, and recalls them ranked by
+ * relevance × importance × recency.
+ */
+declare class Memory {
+    private readonly store;
+    private readonly now;
+    constructor(options?: MemoryOptions);
+    remember(input: RememberInput): Promise<MemoryRecord>;
+    recall(query: string, options?: RecallOptions): Promise<RecallHit[]>;
+    list(options?: {
+        kind?: MemoryKind;
+        limit?: number;
+    }): Promise<MemoryRecord[]>;
+    update(id: string, patch: {
+        content?: string;
+        importance?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<MemoryRecord | null>;
+    forget(id: string): Promise<boolean>;
+    forgetAll(): Promise<void>;
+    /** All records, oldest first — for backup/inspection. */
+    export(): Promise<MemoryRecord[]>;
+    /** Recalled memories rendered as a system-prompt block (Apollo-compatible). */
+    formatBlock(query: string, options?: RecallOptions): Promise<string>;
+}
+/** Lowercase word tokens of length > 2, Unicode-aware. */
+declare function tokenize(text: string): string[];
+/** Render memories as a compact, prompt-ready block. */
+declare function formatMemoriesBlock(memories: MemoryRecord[]): string;
+
+/** Observability types — a legible, replayable record of what an agent did. */
+type TraceEventKind = "mission_start" | "decision" | "plan" | "tool_call" | "approval" | "apply" | "verify" | "memory" | "error" | "mission_end";
+interface TraceEvent {
+    traceId: string;
+    /** Monotonic sequence within the trace. */
+    seq: number;
+    /** ISO-8601 timestamp. */
+    at: string;
+    kind: TraceEventKind;
+    label: string;
+    /** Structured detail, after redaction. */
+    data?: Record<string, unknown>;
+    /** Wall-clock duration, for span events. */
+    durationMs?: number;
+}
+interface Trace {
+    id: string;
+    startedAt?: string;
+    endedAt?: string;
+    events: TraceEvent[];
+}
+/** Scrubs secrets from event detail before it is recorded. */
+type Redactor = (data: Record<string, unknown>) => Record<string, unknown>;
+/** Persistence backend for traces. */
+interface TraceSink {
+    append(event: TraceEvent): Promise<void>;
+    load(traceId: string): Promise<TraceEvent[]>;
+    list(): Promise<string[]>;
+}
+
+/** Default redactor: masks secret-looking keys and known token formats. */
+declare const defaultRedactor: Redactor;
+/** Ephemeral, in-process trace sink. */
+declare class MemorySink implements TraceSink {
+    private readonly traces;
+    append(event: TraceEvent): Promise<void>;
+    load(traceId: string): Promise<TraceEvent[]>;
+    list(): Promise<string[]>;
+}
+/** Append-only JSONL trace sink, one file per trace under `dir`. */
+declare class JsonlSink implements TraceSink {
+    private readonly dir;
+    constructor(dir: string);
+    private file;
+    append(event: TraceEvent): Promise<void>;
+    load(traceId: string): Promise<TraceEvent[]>;
+    list(): Promise<string[]>;
+}
+interface TracerOptions {
+    traceId: string;
+    sink: TraceSink;
+    redactor: Redactor;
+    now: () => Date;
+}
+/** Records the events of a single trace (one agent run / mission). */
+declare class Tracer {
+    readonly traceId: string;
+    private readonly sink;
+    private readonly redactor;
+    private readonly now;
+    private seq;
+    private readonly events;
+    constructor(options: TracerOptions);
+    event(kind: TraceEventKind, label: string, data?: Record<string, unknown>, durationMs?: number): Promise<TraceEvent>;
+    start(label?: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    end(label?: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    decision(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    plan(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    toolCall(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    approval(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    apply(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    verify(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    memory(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    error(label: string, data?: Record<string, unknown>): Promise<TraceEvent>;
+    /** Start a timed span; call `.end()` to record it with a `durationMs`. */
+    span(kind: TraceEventKind, label: string, data?: Record<string, unknown>): {
+        end: (extra?: Record<string, unknown>) => Promise<TraceEvent>;
+    };
+    /** In-memory view of this trace so far. */
+    snapshot(): Trace;
+}
+interface ObservabilityOptions {
+    sink?: TraceSink;
+    /** Persist traces as JSONL under this directory (e.g. `<root>/.origin/traces`). */
+    dir?: string;
+    redactor?: Redactor;
+    now?: () => Date;
+}
+/** Top-level entry point: starts traces and replays them. */
+declare class Observability {
+    private readonly sink;
+    private readonly redactor;
+    private readonly now;
+    constructor(options?: ObservabilityOptions);
+    startTrace(): Tracer;
+    replay(traceId: string): Promise<Trace>;
+    list(): Promise<string[]>;
+}
+
+/** Policy types — the human-agency control surface. */
+/** Maps to Apollo's execution modes (`hermes_compat` = Apollo's streamlined gating). */
+type ApolloMode = "plan" | "review" | "auto" | "full-auto" | "hermes_compat";
+type ActionKind = "read" | "write" | "network" | "exec" | "tool" | "memory" | "plan";
+type Gate = "allow" | "deny" | "ask";
+interface ProposedAction {
+    kind: ActionKind;
+    summary: string;
+    tool?: string;
+    /** Whether the action mutates state / applies a change. */
+    mutating?: boolean;
+    /** Path or resource targeted (used for outside-root checks). */
+    target?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PolicyContext {
+    /** Workspace root, for confining actions. */
+    root?: string;
+}
+interface PolicyBudget {
+    maxSteps: number;
+    maxToolCalls: number;
+    maxUsd?: number;
+}
+interface Policy {
+    readonly name: string;
+    readonly mode: ApolloMode;
+    readonly budget: PolicyBudget;
+    gate(action: ProposedAction, ctx?: PolicyContext): Gate;
+}
+interface ApprovalRequest {
+    action: ProposedAction;
+    policy: string;
+    reason: string;
+}
+interface ApprovalDecision {
+    approved: boolean;
+    note?: string;
+}
+type ApprovalHandler = (req: ApprovalRequest) => Promise<ApprovalDecision> | ApprovalDecision;
+interface AuthorizeResult {
+    allowed: boolean;
+    gate: Gate;
+    via: "policy" | "approver";
+    note?: string;
+}
+
+/**
+ * BYOK provider layer.
+ *
+ * A dependency-free `fetch` wrapper over the major LLM providers. It shares Apollo's
+ * provider set and `ChatMessage` shape, so keys and prompts are drop-in compatible
+ * across Origin and Apollo. Keys are read from the environment — Origin never ships
+ * or stores them.
+ */
+type ChatRole = "system" | "user" | "assistant";
+interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
+declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "google", "groq", "mistral", "openrouter"];
+type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
+/** Environment variables consulted for each provider, in priority order. */
+declare const PROVIDER_KEY_ENV: Record<SupportedProvider, readonly string[]>;
+type Env = Record<string, string | undefined>;
+declare function isSupportedProvider(value: string): value is SupportedProvider;
+/** Resolve an API key for a provider from the environment, or `null` if unset. */
+declare function resolveProviderKey(provider: SupportedProvider, env?: Env): string | null;
+/** List providers that have a usable key in the given environment. */
+declare function availableProviders(env?: Env): SupportedProvider[];
+interface ProviderCall {
+    provider: SupportedProvider;
+    model: string;
+    apiKey: string;
+    messages: ChatMessage[];
+    signal?: AbortSignal;
+    /** Inject a `fetch` implementation (tests, proxies). Defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/** Call a provider and return the assistant's text. Throws on a non-OK response. */
+declare function callProviderText(call: ProviderCall): Promise<string>;
+/** Call a provider and return the raw streaming `Response` (SSE). */
+declare function callProviderStream(call: ProviderCall): Promise<Response>;
+/** Build a per-line SSE delta extractor for a provider's streaming format. */
+declare function makeSSEParser(provider: SupportedProvider): (line: string) => string;
+
+/**
+ * A success contract — the objective, runnable definition of "done". Mirrors
+ * Apollo's contract (commands / http / regex / criteria) so a goal verified by
+ * Origin is verified the same way by Apollo.
+ */
+declare const contractSchema: z.ZodObject<{
+    commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        cmd: z.ZodString;
+        expectExit: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        cmd: string;
+        expectExit: number;
+    }, {
+        cmd: string;
+        expectExit?: number | undefined;
+    }>, "many">>;
+    http: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        expectStatus: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        expectStatus: number;
+    }, {
+        url: string;
+        expectStatus?: number | undefined;
+    }>, "many">>;
+    regex: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        cmd: z.ZodString;
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cmd: string;
+        pattern: string;
+    }, {
+        cmd: string;
+        pattern: string;
+    }>, "many">>;
+    criteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    regex: {
+        cmd: string;
+        pattern: string;
+    }[];
+    commands: {
+        cmd: string;
+        expectExit: number;
+    }[];
+    http: {
+        url: string;
+        expectStatus: number;
+    }[];
+    criteria: string[];
+}, {
+    regex?: {
+        cmd: string;
+        pattern: string;
+    }[] | undefined;
+    commands?: {
+        cmd: string;
+        expectExit?: number | undefined;
+    }[] | undefined;
+    http?: {
+        url: string;
+        expectStatus?: number | undefined;
+    }[] | undefined;
+    criteria?: string[] | undefined;
+}>;
+type Contract = z.infer<typeof contractSchema>;
+interface CheckResult {
+    type: "command" | "http" | "regex";
+    target: string;
+    pass: boolean;
+    detail?: string;
+}
+interface Certificate {
+    ok: boolean;
+    checks: CheckResult[];
+    /** Human-judged criteria, carried through but not auto-evaluated. */
+    criteria: string[];
+    issuedAt: string;
+    /** sha256 over checks + criteria + ok — a tamper-evident fingerprint. */
+    hash: string;
+}
+interface ExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+type ExecFn = (cmd: string, opts: {
+    cwd?: string;
+    timeoutMs?: number;
+}) => Promise<ExecResult>;
+interface EvaluateOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    execImpl?: ExecFn;
+    now?: () => Date;
+}
+/** Run a contract's checks and issue a certificate. */
+declare function evaluateContract(input: unknown, options?: EvaluateOptions): Promise<Certificate>;
+/** Extract a fenced ```contract { … }``` block from an LLM plan, if present. */
+declare function parseContractFromPlan(plan: string): Contract | null;
+
+interface ToolContext {
+    goal: string;
+    signal?: AbortSignal;
+}
+/** A capability the agent can invoke. Inputs are validated by the tool itself. */
+interface Tool {
+    name: string;
+    description?: string;
+    /** Whether invoking the tool mutates state (informs policy gating). */
+    mutating?: boolean;
+    /** Action kind for policy (defaults to "tool"). */
+    kind?: ActionKind;
+    run(input: unknown, ctx: ToolContext): Promise<unknown> | unknown;
+}
+/** Identity helper for authoring tools with inference and a single import. */
+declare function defineTool(spec: Tool): Tool;
+interface PlanStep {
+    id: string;
+    description: string;
+    tool?: string;
+    input?: unknown;
+    kind: ActionKind;
+    mutating: boolean;
+}
+interface Plan {
+    steps: PlanStep[];
+    rationale?: string;
+    /** Optional success contract to verify when the plan completes. */
+    contract?: unknown;
+}
+interface Observation {
+    stepId: string;
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+    skipped?: boolean;
+}
+interface RuntimeContext {
+    goal: string;
+    context: ContextBundle;
+    /** Recalled memory, formatted as a prompt block. */
+    memoryBlock: string;
+    tools: Tool[];
+    signal?: AbortSignal;
+}
+/**
+ * The reasoning/action engine an agent drives. Origin ships a reference runtime;
+ * `@vornicx/origin/apollo` provides one backed by the Apollo CLI.
+ */
+interface Runtime {
+    readonly name: string;
+    plan(ctx: RuntimeContext): Promise<Plan>;
+    synthesize(ctx: RuntimeContext, observations: Observation[]): Promise<string>;
+}
+
+type Completion = (messages: ChatMessage[]) => Promise<string>;
+interface ReferenceRuntimeOptions {
+    /** Provide an LLM completion directly (tests, custom routing). */
+    complete?: Completion;
+    provider?: SupportedProvider;
+    model?: string;
+    env?: Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * A minimal but real reasoning runtime: it plans a goal into steps via an LLM,
+ * then synthesizes a final answer from the executed steps. With no provider key
+ * it degrades to a legible dry run (empty plan + explanatory answer).
+ */
+declare class ReferenceRuntime implements Runtime {
+    readonly name = "reference";
+    private readonly complete?;
+    constructor(options?: ReferenceRuntimeOptions);
+    plan(ctx: RuntimeContext): Promise<Plan>;
+    synthesize(ctx: RuntimeContext, observations: Observation[]): Promise<string>;
+}
+
+interface MissionResult {
+    goal: string;
+    answer: string;
+    steps: PlanStep[];
+    observations: Observation[];
+    certificate?: Certificate;
+    traceId: string;
+    policy: string;
+}
+/**
+ * Options for {@link ApolloAgent}. Only what you care about — everything else
+ * has a sensible default (in-memory Atlas, fresh context, in-memory traces,
+ * human-directed policy, the reference runtime).
+ */
+interface ApolloAgentOptions {
+    /** The Atlas memory layer. Typically `origin.memory`. Defaults to a fresh in-memory store. */
+    memory?: Memory;
+    tools?: Tool[];
+    /** Defaults to `humanDirected()`. */
+    policy?: Policy;
+    context?: ContextEngine;
+    observability?: Observability;
+    /** Approval handler. Defaults to a CLI prompt for review/plan modes, auto-approve for auto modes. */
+    approver?: ApprovalHandler;
+    /** Reasoning/action runtime. Defaults to the built-in reference runtime. */
+    runtime?: Runtime;
+    root?: string;
+    provider?: SupportedProvider;
+    model?: string;
+    /** Provide an LLM completion directly (tests, custom routing). */
+    complete?: Completion;
+}
+/**
+ * Apollo Agent — the composable agent runtime that powers Origin. It reasons
+ * over a goal, uses tools, and acts safely under human control:
+ *
+ * ```ts
+ * const agent = new ApolloAgent({
+ *   memory: origin.memory,
+ *   tools: [calendar, mail, browser],
+ *   policy: humanDirected(),
+ * });
+ * await agent.run("Prepare my launch plan");
+ * ```
+ *
+ * One run is: context → recall → plan → (gate → act → trace) per step →
+ * synthesize → verify → remember. Every decision is traced; every change passes
+ * the policy gate first.
+ *
+ * @see https://archic.es
+ */
+declare class ApolloAgent {
+    readonly memory: Memory;
+    readonly observability: Observability;
+    private readonly tools;
+    private readonly policy;
+    private readonly contextEngine;
+    private readonly approver;
+    private readonly runtime;
+    private readonly root;
+    constructor(options?: ApolloAgentOptions);
+    run(goal: string): Promise<MissionResult>;
+}
+
+interface PolicyOptions {
+    budget?: Partial<PolicyBudget>;
+}
+interface AutonomousOptions extends PolicyOptions {
+    /** Skip outside-root approval prompts. Use only for trusted, bounded tasks. */
+    fullAuto?: boolean;
+}
+/** True if `target`, resolved against `root`, escapes the workspace. */
+declare function outsideRoot(target: string | undefined, root: string | undefined): boolean;
+/**
+ * The default. Read-only work proceeds; anything that changes the world
+ * (write/exec/network/tool) requires human approval before it leaves the gate.
+ */
+declare function humanDirected(options?: PolicyOptions): Policy;
+/** Plan and propose only — never execute. */
+declare function reviewOnly(options?: PolicyOptions): Policy;
+/** Execute within budget and scope. Outside the root still asks, unless full-auto. */
+declare function autonomous(options?: AutonomousOptions): Policy;
+
+export { type Tool as $, type ActionKind as A, type Policy as B, type Certificate as C, type PolicyBudget as D, type EvaluateOptions as E, type FileRef as F, type Gate as G, type PolicyContext as H, InMemoryStore as I, JsonlSink as J, type PolicyOptions as K, type ProposedAction as L, Memory as M, type ProviderCall as N, Observability as O, PROVIDER_KEY_ENV as P, type RecallOptions as Q, type RecallHit as R, type Redactor as S, ReferenceRuntime as T, type ReferenceRuntimeOptions as U, type RememberInput as V, type Runtime as W, type RuntimeContext as X, SUPPORTED_PROVIDERS as Y, type ScanOptions as Z, type SupportedProvider as _, ApolloAgent as a, type ToolContext as a0, type ToolRef as a1, type Trace as a2, type TraceEvent as a3, type TraceEventKind as a4, type TraceSink as a5, Tracer as a6, autonomous as a7, availableProviders as a8, callProviderStream as a9, callProviderText as aa, contractSchema as ab, defaultRedactor as ac, defineTool as ad, evaluateContract as ae, formatMemoriesBlock as af, humanDirected as ag, isSupportedProvider as ah, makeSSEParser as ai, outsideRoot as aj, parseContractFromPlan as ak, parseIntent as al, resolveProviderKey as am, reviewOnly as an, tokenize as ao, type ApolloAgentOptions as b, type ApolloMode as c, type ApprovalDecision as d, type ApprovalHandler as e, type ApprovalRequest as f, type AuthorizeResult as g, type AutonomousOptions as h, type ChatMessage as i, type ChatRole as j, type CheckResult as k, type Completion as l, type ContextBundle as m, ContextEngine as n, type Contract as o, type Intent as p, type MemoryKind as q, type MemoryOptions as r, type MemoryRecord as s, MemorySink as t, type MemoryStore as u, type MissionResult as v, type ObservabilityOptions as w, type Observation as x, type Plan as y, type PlanStep as z };

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@vornicx/origin",
+  "version": "0.1.0",
+  "description": "Origin — a personal intelligence layer: context, memory (Atlas), observability, and human-directed agents. Interoperates with Apollo.",
+  "author": "vornicx",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./apollo": {
+      "types": "./dist/apollo/index.d.ts",
+      "import": "./dist/apollo/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "example:launch": "tsx examples/launch-plan.ts",
+    "example:apollo": "tsx examples/with-apollo.ts",
+    "example:memory": "tsx examples/memory-for-apollo.ts",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "origin",
+    "archic",
+    "apollo",
+    "ai",
+    "agent",
+    "memory",
+    "context",
+    "observability",
+    "llm",
+    "byok",
+    "human-in-the-loop"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vornicx/origin.git"
+  },
+  "homepage": "https://archic.es",
+  "bugs": {
+    "url": "https://github.com/vornicx/origin/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": ">=2",
+    "better-sqlite3": ">=11"
+  },
+  "peerDependenciesMeta": {
+    "@supabase/supabase-js": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.15.0",
+    "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^2.1.8",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
+    "prettier": "^3.4.1",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.16.0",
+    "vitest": "^2.1.8"
+  }
+}