@qmilab/lodestar-core 0.1.0

package/dist/schemas/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,6DAA2D,CAAA;AACzF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;EAGyC,CAAA;AACzE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAIkC,CAAA;AAC9D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD;;GAEG;AACH,eAAO,MAAM,eAAe,aAAwC,CAAA;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD;;GAEG;AACH,eAAO,MAAM,cAAc,aAAyG,CAAA;AACpI,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;EAIvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schemas/common.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * Sensitivity of content. Affects retrieval, explanation generation,
+ * OTel export, and final reports.
+ *
+ * Sensitivity is a content attribute. It is NOT a lifecycle axis —
+ * truth/retrieval/security/freshness describe the *state* of a belief,
+ * sensitivity describes its *content*.
+ */
+export const SensitivitySchema = z.enum(["public", "internal", "confidential", "secret"]);
+/**
+ * Scope a claim, belief, memory, or action applies to. Hierarchical
+ * from broadest (global) to narrowest (session).
+ */
+export const ResourceScopeSchema = z.object({
+    level: z.enum(["global", "organization", "user", "project", "repo", "session"]),
+    identifier: z.string().describe("identifier within the scope level, e.g. project_id"),
+}).describe("Scope that bounds where a claim, belief, or memory applies");
+/**
+ * Structured predicate for queryable claims and beliefs.
+ * Free-form for v0; refined in later versions as the planner matures.
+ */
+export const PredicateSchema = z.object({
+    subject: z.string(),
+    relation: z.string(),
+    object: z.unknown(),
+}).describe("Structured form of a claim suitable for queries");
+/**
+ * ISO 8601 timestamp string.
+ */
+export const TimestampSchema = z.string().datetime({ offset: true });
+/**
+ * ISO 8601 duration string (e.g. "P30D", "PT1H").
+ */
+export const DurationSchema = z.string().regex(/^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/);
+/**
+ * Generic Source reference used in evidence and explanations.
+ * Points to an observation, belief, or external identifier.
+ */
+export const SourceSchema = z.object({
+    type: z.enum(["observation", "belief", "claim", "memory", "skill", "external"]),
+    id: z.string(),
+    uri: z.string().optional().describe("optional external URI, for type=external"),
+});
+//# sourceMappingURL=common.js.map

package/dist/schemas/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAA;AAGzF;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IAC/E,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,oDAAoD,CAAC;CACtF,CAAC,CAAC,QAAQ,CAAC,4DAA4D,CAAC,CAAA;AAGzE;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;CACpB,CAAC,CAAC,QAAQ,CAAC,iDAAiD,CAAC,CAAA;AAG9D;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;AAGpE;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,oFAAoF,CAAC,CAAA;AAGpI;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAC/E,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0CAA0C,CAAC;CAChF,CAAC,CAAA"}

package/dist/schemas/decision.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+/**
+ * One option in a decision.
+ */
+export declare const DecisionOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    expected_outcome: z.ZodOptional<z.ZodString>;
+    estimated_cost: z.ZodOptional<z.ZodString>;
+    estimated_risk: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    expected_outcome?: string | undefined;
+    estimated_cost?: string | undefined;
+    estimated_risk?: string | undefined;
+}, {
+    id: string;
+    description: string;
+    expected_outcome?: string | undefined;
+    estimated_cost?: string | undefined;
+    estimated_risk?: string | undefined;
+}>;
+export type DecisionOption = z.infer<typeof DecisionOptionSchema>;
+/**
+ * A choice among options, justified by beliefs.
+ *
+ * Decisions sit between Belief and Action in the epistemic chain.
+ * Every Decision records its belief_dependencies — the policy can
+ * reject Decisions that lack supporting beliefs (governed by
+ * ContextPolicy.require_evidence_for_decisions).
+ *
+ * The rationale_id points to an Explanation generated alongside
+ * the decision. This is how the system stays auditable: every
+ * decision has a stored reasoning trail, not just a regenerable one.
+ */
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        expected_outcome: z.ZodOptional<z.ZodString>;
+        estimated_cost: z.ZodOptional<z.ZodString>;
+        estimated_risk: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        expected_outcome?: string | undefined;
+        estimated_cost?: string | undefined;
+        estimated_risk?: string | undefined;
+    }, {
+        id: string;
+        description: string;
+        expected_outcome?: string | undefined;
+        estimated_cost?: string | undefined;
+        estimated_risk?: string | undefined;
+    }>, "many">;
+    selected_option_id: z.ZodString;
+    rationale_id: z.ZodString;
+    belief_dependencies: z.ZodArray<z.ZodString, "many">;
+    policy_dependencies: z.ZodArray<z.ZodString, "many">;
+    outcome_id: z.ZodOptional<z.ZodString>;
+    made_by: z.ZodString;
+    made_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        id: string;
+        description: string;
+        expected_outcome?: string | undefined;
+        estimated_cost?: string | undefined;
+        estimated_risk?: string | undefined;
+    }[];
+    id: string;
+    question: string;
+    selected_option_id: string;
+    rationale_id: string;
+    belief_dependencies: string[];
+    policy_dependencies: string[];
+    made_by: string;
+    made_at: string;
+    outcome_id?: string | undefined;
+}, {
+    options: {
+        id: string;
+        description: string;
+        expected_outcome?: string | undefined;
+        estimated_cost?: string | undefined;
+        estimated_risk?: string | undefined;
+    }[];
+    id: string;
+    question: string;
+    selected_option_id: string;
+    rationale_id: string;
+    belief_dependencies: string[];
+    policy_dependencies: string[];
+    made_by: string;
+    made_at: string;
+    outcome_id?: string | undefined;
+}>;
+export type Decision = z.infer<typeof DecisionSchema>;
+//# sourceMappingURL=decision.d.ts.map

package/dist/schemas/decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.d.ts","sourceRoot":"","sources":["../../src/schemas/decision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAM/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/schemas/decision.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { TimestampSchema } from "./common";
+/**
+ * One option in a decision.
+ */
+export const DecisionOptionSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    expected_outcome: z.string().optional(),
+    estimated_cost: z.string().optional().describe("free-form for v0; e.g. 'low', 'medium', 'high'"),
+    estimated_risk: z.string().optional(),
+});
+/**
+ * A choice among options, justified by beliefs.
+ *
+ * Decisions sit between Belief and Action in the epistemic chain.
+ * Every Decision records its belief_dependencies — the policy can
+ * reject Decisions that lack supporting beliefs (governed by
+ * ContextPolicy.require_evidence_for_decisions).
+ *
+ * The rationale_id points to an Explanation generated alongside
+ * the decision. This is how the system stays auditable: every
+ * decision has a stored reasoning trail, not just a regenerable one.
+ */
+export const DecisionSchema = z.object({
+    id: z.string(),
+    question: z.string().describe("human-readable question this decision answers"),
+    options: z.array(DecisionOptionSchema).min(1),
+    selected_option_id: z.string(),
+    rationale_id: z.string().describe("Explanation id"),
+    belief_dependencies: z.array(z.string()).describe("belief_ids consulted"),
+    policy_dependencies: z.array(z.string()).describe("policy versions consulted"),
+    outcome_id: z.string().optional().describe("populated after Action completes"),
+    made_by: z.string().describe("actor_id"),
+    made_at: TimestampSchema,
+});
+//# sourceMappingURL=decision.js.map

package/dist/schemas/decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.js","sourceRoot":"","sources":["../../src/schemas/decision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACvC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gDAAgD,CAAC;IAChG,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAA;AAGF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,+CAA+C,CAAC;IAC9E,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7C,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC9B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IACnD,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,sBAAsB,CAAC;IACzE,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IAC9E,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IAC9E,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;IACxC,OAAO,EAAE,eAAe;CACzB,CAAC,CAAA"}

package/dist/schemas/event.d.ts

@@ -0,0 +1,171 @@
+import { z } from "zod";
+/**
+ * Version metadata attached to every event.
+ *
+ * Replay-grade events need to know which model, prompt, tool version,
+ * skill version, policy version, and memory snapshot were in effect
+ * when the event was produced. Without this, replays cannot reproduce
+ * the original conditions.
+ */
+export declare const EventVersionsSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    prompt_hash: z.ZodOptional<z.ZodString>;
+    tool_version: z.ZodOptional<z.ZodString>;
+    skill_hash: z.ZodOptional<z.ZodString>;
+    policy_version: z.ZodOptional<z.ZodString>;
+    memory_snapshot_id: z.ZodOptional<z.ZodString>;
+    schema_registry_version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model?: string | undefined;
+    prompt_hash?: string | undefined;
+    tool_version?: string | undefined;
+    skill_hash?: string | undefined;
+    policy_version?: string | undefined;
+    memory_snapshot_id?: string | undefined;
+    schema_registry_version?: string | undefined;
+}, {
+    model?: string | undefined;
+    prompt_hash?: string | undefined;
+    tool_version?: string | undefined;
+    skill_hash?: string | undefined;
+    policy_version?: string | undefined;
+    memory_snapshot_id?: string | undefined;
+    schema_registry_version?: string | undefined;
+}>;
+export type EventVersions = z.infer<typeof EventVersionsSchema>;
+/**
+ * The envelope every event in Lodestar is wrapped in.
+ *
+ * Append-only. NDJSON-friendly. Replay-grade.
+ *
+ * - `seq` is a monotonic per-partition sequence number; used for
+ *   deterministic replay ordering.
+ * - `logical_clock` is a Lamport-style counter; used to reason about
+ *   causality across actors within a session.
+ * - `causal_parent_ids` form a DAG that lets the harness reconstruct
+ *   why an event happened.
+ * - `payload_hash` is sha-256 of the canonical payload; gives
+ *   tamper-evidence without requiring per-event signatures.
+ * - `signature` is OPTIONAL in v0. Routine internal events rely on
+ *   the hash + append-only log. Signatures are required only for
+ *   skills, policy versions, external imports, and secret-signing
+ *   events. Adding a signature field for every event is overkill in v0.
+ */
+export declare const EventEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    seq: z.ZodNumber;
+    type: z.ZodString;
+    schema_version: z.ZodString;
+    project_id: z.ZodString;
+    session_id: z.ZodString;
+    actor_id: z.ZodString;
+    timestamp: z.ZodString;
+    logical_clock: z.ZodNumber;
+    causal_parent_ids: z.ZodArray<z.ZodString, "many">;
+    payload_hash: z.ZodString;
+    payload: z.ZodUnknown;
+    versions: z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        prompt_hash: z.ZodOptional<z.ZodString>;
+        tool_version: z.ZodOptional<z.ZodString>;
+        skill_hash: z.ZodOptional<z.ZodString>;
+        policy_version: z.ZodOptional<z.ZodString>;
+        memory_snapshot_id: z.ZodOptional<z.ZodString>;
+        schema_registry_version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model?: string | undefined;
+        prompt_hash?: string | undefined;
+        tool_version?: string | undefined;
+        skill_hash?: string | undefined;
+        policy_version?: string | undefined;
+        memory_snapshot_id?: string | undefined;
+        schema_registry_version?: string | undefined;
+    }, {
+        model?: string | undefined;
+        prompt_hash?: string | undefined;
+        tool_version?: string | undefined;
+        skill_hash?: string | undefined;
+        policy_version?: string | undefined;
+        memory_snapshot_id?: string | undefined;
+        schema_registry_version?: string | undefined;
+    }>;
+    signature: z.ZodOptional<z.ZodObject<{
+        signer_id: z.ZodString;
+        payload_hash: z.ZodString;
+        algorithm: z.ZodLiteral<"ed25519">;
+        signature: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        signer_id: string;
+        payload_hash: string;
+        algorithm: "ed25519";
+        signature: string;
+    }, {
+        at: string;
+        signer_id: string;
+        payload_hash: string;
+        algorithm: "ed25519";
+        signature: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: string;
+    payload_hash: string;
+    session_id: string;
+    project_id: string;
+    actor_id: string;
+    seq: number;
+    schema_version: string;
+    timestamp: string;
+    logical_clock: number;
+    causal_parent_ids: string[];
+    versions: {
+        model?: string | undefined;
+        prompt_hash?: string | undefined;
+        tool_version?: string | undefined;
+        skill_hash?: string | undefined;
+        policy_version?: string | undefined;
+        memory_snapshot_id?: string | undefined;
+        schema_registry_version?: string | undefined;
+    };
+    signature?: {
+        at: string;
+        signer_id: string;
+        payload_hash: string;
+        algorithm: "ed25519";
+        signature: string;
+    } | undefined;
+    payload?: unknown;
+}, {
+    type: string;
+    id: string;
+    payload_hash: string;
+    session_id: string;
+    project_id: string;
+    actor_id: string;
+    seq: number;
+    schema_version: string;
+    timestamp: string;
+    logical_clock: number;
+    causal_parent_ids: string[];
+    versions: {
+        model?: string | undefined;
+        prompt_hash?: string | undefined;
+        tool_version?: string | undefined;
+        skill_hash?: string | undefined;
+        policy_version?: string | undefined;
+        memory_snapshot_id?: string | undefined;
+        schema_registry_version?: string | undefined;
+    };
+    signature?: {
+        at: string;
+        signer_id: string;
+        payload_hash: string;
+        algorithm: "ed25519";
+        signature: string;
+    } | undefined;
+    payload?: unknown;
+}>;
+export type EventEnvelope = z.infer<typeof EventEnvelopeSchema>;
+//# sourceMappingURL=event.d.ts.map

package/dist/schemas/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/schemas/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAQ9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schemas/event.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { SignatureSchema } from "./actor";
+import { TimestampSchema } from "./common";
+/**
+ * Version metadata attached to every event.
+ *
+ * Replay-grade events need to know which model, prompt, tool version,
+ * skill version, policy version, and memory snapshot were in effect
+ * when the event was produced. Without this, replays cannot reproduce
+ * the original conditions.
+ */
+export const EventVersionsSchema = z.object({
+    model: z.string().optional().describe("e.g. 'claude-opus-4-7'"),
+    prompt_hash: z.string().optional(),
+    tool_version: z.string().optional(),
+    skill_hash: z.string().optional(),
+    policy_version: z.string().optional(),
+    memory_snapshot_id: z.string().optional(),
+    schema_registry_version: z.string().optional(),
+});
+/**
+ * The envelope every event in Lodestar is wrapped in.
+ *
+ * Append-only. NDJSON-friendly. Replay-grade.
+ *
+ * - `seq` is a monotonic per-partition sequence number; used for
+ *   deterministic replay ordering.
+ * - `logical_clock` is a Lamport-style counter; used to reason about
+ *   causality across actors within a session.
+ * - `causal_parent_ids` form a DAG that lets the harness reconstruct
+ *   why an event happened.
+ * - `payload_hash` is sha-256 of the canonical payload; gives
+ *   tamper-evidence without requiring per-event signatures.
+ * - `signature` is OPTIONAL in v0. Routine internal events rely on
+ *   the hash + append-only log. Signatures are required only for
+ *   skills, policy versions, external imports, and secret-signing
+ *   events. Adding a signature field for every event is overkill in v0.
+ */
+export const EventEnvelopeSchema = z.object({
+    id: z.string(),
+    seq: z.number().int().nonnegative(),
+    type: z.string().describe("e.g. 'action.approved', 'memory.promoted'"),
+    schema_version: z.string().describe("semver of this event type"),
+    project_id: z.string(),
+    session_id: z.string(),
+    actor_id: z.string(),
+    timestamp: TimestampSchema,
+    logical_clock: z.number().int().nonnegative(),
+    causal_parent_ids: z.array(z.string()),
+    payload_hash: z.string().describe("sha-256 hex"),
+    payload: z.unknown(),
+    versions: EventVersionsSchema,
+    signature: SignatureSchema.optional(),
+});
+//# sourceMappingURL=event.js.map

package/dist/schemas/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/schemas/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IAC/D,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzC,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/C,CAAC,CAAA;AAGF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACnC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACtE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IAChE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,SAAS,EAAE,eAAe;IAC1B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC7C,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACtC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC;IAChD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,QAAQ,EAAE,mBAAmB;IAC7B,SAAS,EAAE,eAAe,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAA"}

package/dist/schemas/observation.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+/**
+ * Trust level of an observation's source.
+ *
+ * - "raw": just arrived from a tool, not yet validated by schema registry
+ * - "validated": validated against its registered schema, ready for cognition
+ * - "synthetic": produced by a probe; must not pollute real memory
+ */
+export declare const ObservationTrustSchema: z.ZodEnum<["raw", "validated", "synthetic"]>;
+export type ObservationTrust = z.infer<typeof ObservationTrustSchema>;
+/**
+ * The first link in the epistemic chain.
+ *
+ * An Observation is a schema-typed structured input produced by a tool.
+ * Free-form strings from a tool are NOT observations until they have
+ * been validated against a registered schema.
+ *
+ * The `schema` field references the registry entry (e.g. "git.status@1").
+ * The kernel validates `payload` against that schema before this becomes
+ * a `validated` observation.
+ */
+export declare const ObservationSchema: z.ZodObject<{
+    id: z.ZodString;
+    schema: z.ZodString;
+    payload: z.ZodUnknown;
+    source: z.ZodObject<{
+        tool: z.ZodString;
+        invocation_id: z.ZodString;
+        captured_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        invocation_id: string;
+        captured_at: string;
+    }, {
+        tool: string;
+        invocation_id: string;
+        captured_at: string;
+    }>;
+    context: z.ZodObject<{
+        session_id: z.ZodString;
+        project_id: z.ZodString;
+        actor_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        session_id: string;
+        project_id: string;
+        actor_id: string;
+    }, {
+        session_id: string;
+        project_id: string;
+        actor_id: string;
+    }>;
+    trust: z.ZodEnum<["raw", "validated", "synthetic"]>;
+    sensitivity: z.ZodEnum<["public", "internal", "confidential", "secret"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    schema: string;
+    source: {
+        tool: string;
+        invocation_id: string;
+        captured_at: string;
+    };
+    context: {
+        session_id: string;
+        project_id: string;
+        actor_id: string;
+    };
+    trust: "raw" | "validated" | "synthetic";
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    payload?: unknown;
+}, {
+    id: string;
+    schema: string;
+    source: {
+        tool: string;
+        invocation_id: string;
+        captured_at: string;
+    };
+    context: {
+        session_id: string;
+        project_id: string;
+        actor_id: string;
+    };
+    trust: "raw" | "validated" | "synthetic";
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    payload?: unknown;
+}>;
+export type Observation = z.infer<typeof ObservationSchema>;
+//# sourceMappingURL=observation.d.ts.map

package/dist/schemas/observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../../src/schemas/observation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,8CAA4C,CAAA;AAC/E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schemas/observation.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { SensitivitySchema, TimestampSchema } from "./common";
+/**
+ * Trust level of an observation's source.
+ *
+ * - "raw": just arrived from a tool, not yet validated by schema registry
+ * - "validated": validated against its registered schema, ready for cognition
+ * - "synthetic": produced by a probe; must not pollute real memory
+ */
+export const ObservationTrustSchema = z.enum(["raw", "validated", "synthetic"]);
+/**
+ * The first link in the epistemic chain.
+ *
+ * An Observation is a schema-typed structured input produced by a tool.
+ * Free-form strings from a tool are NOT observations until they have
+ * been validated against a registered schema.
+ *
+ * The `schema` field references the registry entry (e.g. "git.status@1").
+ * The kernel validates `payload` against that schema before this becomes
+ * a `validated` observation.
+ */
+export const ObservationSchema = z.object({
+    id: z.string(),
+    schema: z.string().describe("registry key, e.g. 'git.status@1'"),
+    payload: z.unknown(),
+    source: z.object({
+        tool: z.string(),
+        invocation_id: z.string(),
+        captured_at: TimestampSchema,
+    }),
+    context: z.object({
+        session_id: z.string(),
+        project_id: z.string(),
+        actor_id: z.string(),
+    }),
+    trust: ObservationTrustSchema,
+    sensitivity: SensitivitySchema,
+});
+//# sourceMappingURL=observation.js.map

package/dist/schemas/observation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.js","sourceRoot":"","sources":["../../src/schemas/observation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAA;AAG/E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IAChE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;QACzB,WAAW,EAAE,eAAe;KAC7B,CAAC;IACF,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC;QAChB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;QACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;QACtB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;KACrB,CAAC;IACF,KAAK,EAAE,sBAAsB;IAC7B,WAAW,EAAE,iBAAiB;CAC/B,CAAC,CAAA"}