@qmilab/lodestar-core 0.1.0

package/dist/schemas/belief.d.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+export declare const TruthStatusSchema: z.ZodEnum<["unverified", "supported", "contradicted", "superseded"]>;
+export type TruthStatus = z.infer<typeof TruthStatusSchema>;
+export declare const RetrievalStatusSchema: z.ZodEnum<["hidden", "restricted", "normal", "privileged_only", "blocked"]>;
+export type RetrievalStatus = z.infer<typeof RetrievalStatusSchema>;
+export declare const SecurityStatusSchema: z.ZodEnum<["clean", "suspicious", "quarantined", "malicious"]>;
+export type SecurityStatus = z.infer<typeof SecurityStatusSchema>;
+export declare const FreshnessStatusSchema: z.ZodEnum<["fresh", "stale", "expired"]>;
+export type FreshnessStatus = z.infer<typeof FreshnessStatusSchema>;
+/**
+ * How a belief came to be adopted.
+ *
+ * - observed: derived from tool observations
+ * - inferred: derived by an LLM from other context
+ * - user_asserted: user said so directly
+ * - policy_asserted: policy configuration (e.g. "do not push to main")
+ * - imported: from an external knowledge import
+ * - synthetic: from a probe; never affects real reasoning
+ *
+ * user_asserted and policy_asserted beliefs do NOT decay like
+ * observations. They expire only via explicit revision.
+ */
+export declare const BeliefAuthoritySchema: z.ZodEnum<["observed", "inferred", "user_asserted", "policy_asserted", "imported", "synthetic"]>;
+export type BeliefAuthority = z.infer<typeof BeliefAuthoritySchema>;
+/**
+ * A claim the system has provisionally adopted.
+ *
+ * Every belief points to a claim (`claim_id`). The belief carries
+ * lifecycle state, confidence, calibration class, scope, sensitivity,
+ * and authority. The claim carries the statement itself.
+ *
+ * Confidence is the agent's stated confidence. The Calibrator measures
+ * empirical accuracy per calibration_class and can require the Policy
+ * Kernel to downweight confidence in classes where the agent is
+ * historically overconfident.
+ */
+export declare const BeliefSchema: z.ZodObject<{
+    id: z.ZodString;
+    claim_id: z.ZodString;
+    confidence: z.ZodNumber;
+    calibration_class: z.ZodString;
+    scope: z.ZodObject<{
+        level: z.ZodEnum<["global", "organization", "user", "project", "repo", "session"]>;
+        identifier: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    }, {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    }>;
+    sensitivity: z.ZodEnum<["public", "internal", "confidential", "secret"]>;
+    authority: z.ZodEnum<["observed", "inferred", "user_asserted", "policy_asserted", "imported", "synthetic"]>;
+    truth_status: z.ZodEnum<["unverified", "supported", "contradicted", "superseded"]>;
+    retrieval_status: z.ZodEnum<["hidden", "restricted", "normal", "privileged_only", "blocked"]>;
+    security_status: z.ZodEnum<["clean", "suspicious", "quarantined", "malicious"]>;
+    freshness_status: z.ZodEnum<["fresh", "stale", "expired"]>;
+    observed_at: z.ZodString;
+    last_verified_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    superseded_by: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    scope: {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    };
+    claim_id: string;
+    confidence: number;
+    calibration_class: string;
+    authority: "imported" | "synthetic" | "observed" | "inferred" | "user_asserted" | "policy_asserted";
+    truth_status: "unverified" | "supported" | "contradicted" | "superseded";
+    retrieval_status: "hidden" | "restricted" | "normal" | "privileged_only" | "blocked";
+    security_status: "clean" | "suspicious" | "quarantined" | "malicious";
+    freshness_status: "fresh" | "stale" | "expired";
+    observed_at: string;
+    last_verified_at?: string | undefined;
+    expires_at?: string | undefined;
+    superseded_by?: string | undefined;
+}, {
+    id: string;
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    scope: {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    };
+    claim_id: string;
+    confidence: number;
+    calibration_class: string;
+    authority: "imported" | "synthetic" | "observed" | "inferred" | "user_asserted" | "policy_asserted";
+    truth_status: "unverified" | "supported" | "contradicted" | "superseded";
+    retrieval_status: "hidden" | "restricted" | "normal" | "privileged_only" | "blocked";
+    security_status: "clean" | "suspicious" | "quarantined" | "malicious";
+    freshness_status: "fresh" | "stale" | "expired";
+    observed_at: string;
+    last_verified_at?: string | undefined;
+    expires_at?: string | undefined;
+    superseded_by?: string | undefined;
+}>;
+export type Belief = z.infer<typeof BeliefSchema>;
+export declare const ContextPolicySchema: z.ZodObject<{
+    allowed_truth_statuses: z.ZodArray<z.ZodEnum<["unverified", "supported", "contradicted", "superseded"]>, "many">;
+    allowed_retrieval_statuses: z.ZodArray<z.ZodEnum<["hidden", "restricted", "normal", "privileged_only", "blocked"]>, "many">;
+    allowed_security_statuses: z.ZodArray<z.ZodEnum<["clean", "suspicious", "quarantined", "malicious"]>, "many">;
+    freshness_max_age: z.ZodOptional<z.ZodString>;
+    sensitivity_ceiling: z.ZodEnum<["public", "internal", "confidential", "secret"]>;
+    include_contradictions: z.ZodBoolean;
+    include_uncertainties: z.ZodBoolean;
+    require_evidence_for_decisions: z.ZodBoolean;
+    user_asserted_takes_priority: z.ZodBoolean;
+    policy_asserted_takes_priority: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    allowed_truth_statuses: ("unverified" | "supported" | "contradicted" | "superseded")[];
+    allowed_retrieval_statuses: ("hidden" | "restricted" | "normal" | "privileged_only" | "blocked")[];
+    allowed_security_statuses: ("clean" | "suspicious" | "quarantined" | "malicious")[];
+    sensitivity_ceiling: "public" | "internal" | "confidential" | "secret";
+    include_contradictions: boolean;
+    include_uncertainties: boolean;
+    require_evidence_for_decisions: boolean;
+    user_asserted_takes_priority: boolean;
+    policy_asserted_takes_priority: boolean;
+    freshness_max_age?: string | undefined;
+}, {
+    allowed_truth_statuses: ("unverified" | "supported" | "contradicted" | "superseded")[];
+    allowed_retrieval_statuses: ("hidden" | "restricted" | "normal" | "privileged_only" | "blocked")[];
+    allowed_security_statuses: ("clean" | "suspicious" | "quarantined" | "malicious")[];
+    sensitivity_ceiling: "public" | "internal" | "confidential" | "secret";
+    include_contradictions: boolean;
+    include_uncertainties: boolean;
+    require_evidence_for_decisions: boolean;
+    user_asserted_takes_priority: boolean;
+    policy_asserted_takes_priority: boolean;
+    freshness_max_age?: string | undefined;
+}>;
+export type ContextPolicy = z.infer<typeof ContextPolicySchema>;
+/**
+ * Conservative v0 default. Tightens up as the system proves itself.
+ */
+export declare const DEFAULT_CONTEXT_POLICY: ContextPolicy;
+//# sourceMappingURL=belief.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"belief.d.ts","sourceRoot":"","sources":["../../src/schemas/belief.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,iBAAiB,sEAAoE,CAAA;AAClG,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,qBAAqB,6EAA2E,CAAA;AAC7G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB,gEAA8D,CAAA;AAC/F,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,qBAAqB,0CAAwC,CAAA;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,kGAOhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAWjD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAWpC,CAAA"}

package/dist/schemas/belief.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { DurationSchema, ResourceScopeSchema, SensitivitySchema, TimestampSchema, } from "./common";
+// -----------------------------------------------------------------------------
+// Orthogonal lifecycle axes
+//
+// A belief's state is described by four independent dimensions. Collapsing
+// them into a single enum is the wrong abstraction: a belief can be
+// "supported but stale", "supported but quarantined", "contradicted but
+// fresh", and so on. The axes are independently updated and independently
+// gate retrieval.
+// -----------------------------------------------------------------------------
+export const TruthStatusSchema = z.enum(["unverified", "supported", "contradicted", "superseded"]);
+export const RetrievalStatusSchema = z.enum(["hidden", "restricted", "normal", "privileged_only", "blocked"]);
+export const SecurityStatusSchema = z.enum(["clean", "suspicious", "quarantined", "malicious"]);
+export const FreshnessStatusSchema = z.enum(["fresh", "stale", "expired"]);
+/**
+ * How a belief came to be adopted.
+ *
+ * - observed: derived from tool observations
+ * - inferred: derived by an LLM from other context
+ * - user_asserted: user said so directly
+ * - policy_asserted: policy configuration (e.g. "do not push to main")
+ * - imported: from an external knowledge import
+ * - synthetic: from a probe; never affects real reasoning
+ *
+ * user_asserted and policy_asserted beliefs do NOT decay like
+ * observations. They expire only via explicit revision.
+ */
+export const BeliefAuthoritySchema = z.enum([
+    "observed",
+    "inferred",
+    "user_asserted",
+    "policy_asserted",
+    "imported",
+    "synthetic",
+]);
+/**
+ * A claim the system has provisionally adopted.
+ *
+ * Every belief points to a claim (`claim_id`). The belief carries
+ * lifecycle state, confidence, calibration class, scope, sensitivity,
+ * and authority. The claim carries the statement itself.
+ *
+ * Confidence is the agent's stated confidence. The Calibrator measures
+ * empirical accuracy per calibration_class and can require the Policy
+ * Kernel to downweight confidence in classes where the agent is
+ * historically overconfident.
+ */
+export const BeliefSchema = z.object({
+    id: z.string(),
+    claim_id: z.string(),
+    confidence: z.number().min(0).max(1),
+    calibration_class: z.string().describe("groups similar beliefs for calibrator"),
+    scope: ResourceScopeSchema,
+    sensitivity: SensitivitySchema,
+    authority: BeliefAuthoritySchema,
+    // Orthogonal lifecycle axes
+    truth_status: TruthStatusSchema,
+    retrieval_status: RetrievalStatusSchema,
+    security_status: SecurityStatusSchema,
+    freshness_status: FreshnessStatusSchema,
+    observed_at: TimestampSchema,
+    last_verified_at: TimestampSchema.optional(),
+    expires_at: TimestampSchema.optional(),
+    superseded_by: z.string().optional().describe("belief_id of successor"),
+});
+// -----------------------------------------------------------------------------
+// ContextPolicy
+//
+// What the cognitive core may load into model context. Without an explicit
+// policy, "the planner used a stale belief" or "the explanation leaked a
+// secret claim" become invisible bugs. With it, those become testable
+// invariants.
+// -----------------------------------------------------------------------------
+export const ContextPolicySchema = z.object({
+    // Which lifecycle states may be loaded
+    allowed_truth_statuses: z.array(TruthStatusSchema),
+    allowed_retrieval_statuses: z.array(RetrievalStatusSchema),
+    allowed_security_statuses: z.array(SecurityStatusSchema),
+    // Freshness gate
+    freshness_max_age: DurationSchema.optional(),
+    // Sensitivity ceiling for what can enter context
+    sensitivity_ceiling: SensitivitySchema,
+    // What the planner sees
+    include_contradictions: z.boolean(),
+    include_uncertainties: z.boolean(),
+    require_evidence_for_decisions: z.boolean(),
+    // Authority handling
+    user_asserted_takes_priority: z.boolean(),
+    policy_asserted_takes_priority: z.boolean(),
+});
+/**
+ * Conservative v0 default. Tightens up as the system proves itself.
+ */
+export const DEFAULT_CONTEXT_POLICY = {
+    allowed_truth_statuses: ["supported"],
+    allowed_retrieval_statuses: ["normal"],
+    allowed_security_statuses: ["clean"],
+    freshness_max_age: "P30D",
+    sensitivity_ceiling: "internal",
+    include_contradictions: true,
+    include_uncertainties: true,
+    require_evidence_for_decisions: true,
+    user_asserted_takes_priority: true,
+    policy_asserted_takes_priority: true,
+};
+//# sourceMappingURL=belief.js.map

package/dist/schemas/belief.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"belief.js","sourceRoot":"","sources":["../../src/schemas/belief.ts"],"names":[],"mappings":"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"}

package/dist/schemas/claim.d.ts

@@ -0,0 +1,234 @@
+import { z } from "zod";
+/**
+ * How a claim was extracted from observation(s).
+ */
+export declare const ExtractionMethodSchema: z.ZodEnum<["tool", "llm", "human", "import"]>;
+export type ExtractionMethod = z.infer<typeof ExtractionMethodSchema>;
+/**
+ * Lifecycle of a claim before it becomes a belief.
+ */
+export declare const ClaimStatusSchema: z.ZodEnum<["extracted", "contested", "accepted", "rejected"]>;
+export type ClaimStatus = z.infer<typeof ClaimStatusSchema>;
+/**
+ * Dissent recorded against a claim. Reserved for multi-agent futures;
+ * v0 captures it but the resolution algorithm is deferred.
+ */
+export declare const DissentSchema: z.ZodObject<{
+    by_actor_id: z.ZodString;
+    reason: z.ZodString;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    by_actor_id: string;
+    reason: string;
+}, {
+    at: string;
+    by_actor_id: string;
+    reason: string;
+}>;
+export type Dissent = z.infer<typeof DissentSchema>;
+/**
+ * A statement extracted from one or more observations.
+ *
+ * Claims are the second link in the epistemic chain. Every claim
+ * records its extraction method and the actor that extracted it,
+ * so the source of an eventual belief can always be traced back to
+ * the original observation(s).
+ */
+export declare const ClaimSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    structured_predicate: z.ZodOptional<z.ZodObject<{
+        subject: z.ZodString;
+        relation: z.ZodString;
+        object: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        subject: string;
+        relation: string;
+        object?: unknown;
+    }, {
+        subject: string;
+        relation: string;
+        object?: unknown;
+    }>>;
+    source_observation_ids: z.ZodArray<z.ZodString, "many">;
+    extraction_method: z.ZodEnum<["tool", "llm", "human", "import"]>;
+    extracted_by: z.ZodString;
+    status: z.ZodEnum<["extracted", "contested", "accepted", "rejected"]>;
+    scope: z.ZodObject<{
+        level: z.ZodEnum<["global", "organization", "user", "project", "repo", "session"]>;
+        identifier: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    }, {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    }>;
+    sensitivity: z.ZodEnum<["public", "internal", "confidential", "secret"]>;
+    authors: z.ZodArray<z.ZodString, "many">;
+    dissent: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        by_actor_id: z.ZodString;
+        reason: z.ZodString;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        by_actor_id: string;
+        reason: string;
+    }, {
+        at: string;
+        by_actor_id: string;
+        reason: string;
+    }>, "many">>;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "extracted" | "contested" | "accepted" | "rejected";
+    id: string;
+    created_at: string;
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    statement: string;
+    source_observation_ids: string[];
+    extraction_method: "human" | "tool" | "llm" | "import";
+    extracted_by: string;
+    scope: {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    };
+    authors: string[];
+    structured_predicate?: {
+        subject: string;
+        relation: string;
+        object?: unknown;
+    } | undefined;
+    dissent?: {
+        at: string;
+        by_actor_id: string;
+        reason: string;
+    }[] | undefined;
+}, {
+    status: "extracted" | "contested" | "accepted" | "rejected";
+    id: string;
+    created_at: string;
+    sensitivity: "public" | "internal" | "confidential" | "secret";
+    statement: string;
+    source_observation_ids: string[];
+    extraction_method: "human" | "tool" | "llm" | "import";
+    extracted_by: string;
+    scope: {
+        level: "global" | "organization" | "user" | "project" | "repo" | "session";
+        identifier: string;
+    };
+    authors: string[];
+    structured_predicate?: {
+        subject: string;
+        relation: string;
+        object?: unknown;
+    } | undefined;
+    dissent?: {
+        at: string;
+        by_actor_id: string;
+        reason: string;
+    }[] | undefined;
+}>;
+export type Claim = z.infer<typeof ClaimSchema>;
+/**
+ * Quality of a single piece of evidence.
+ *
+ * v0 uses a categorical taxonomy. A scalar evidence strength is
+ * deferred to later versions once enough data exists to calibrate
+ * a scoring function.
+ */
+export declare const EvidenceQualitySchema: z.ZodEnum<["direct_observation", "tool_result", "human_assertion", "model_inference", "external_document", "synthetic_probe"]>;
+export type EvidenceQuality = z.infer<typeof EvidenceQualitySchema>;
+/**
+ * One piece of evidence for or against a claim.
+ *
+ * `independence_group` is used by aggregators: items in the same group
+ * are NOT independent. This matters because three citations to the same
+ * source are not three independent supporting items.
+ */
+export declare const EvidenceItemSchema: z.ZodObject<{
+    source_id: z.ZodString;
+    relation: z.ZodEnum<["supports", "contradicts", "contextualizes"]>;
+    quality: z.ZodEnum<["direct_observation", "tool_result", "human_assertion", "model_inference", "external_document", "synthetic_probe"]>;
+    independence_group: z.ZodOptional<z.ZodString>;
+    freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    relation: "supports" | "contradicts" | "contextualizes";
+    source_id: string;
+    quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+    freshness: "unknown" | "fresh" | "stale";
+    independence_group?: string | undefined;
+    notes?: string | undefined;
+}, {
+    relation: "supports" | "contradicts" | "contextualizes";
+    source_id: string;
+    quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+    freshness: "unknown" | "fresh" | "stale";
+    independence_group?: string | undefined;
+    notes?: string | undefined;
+}>;
+export type EvidenceItem = z.infer<typeof EvidenceItemSchema>;
+/**
+ * Set of evidence assessed against a claim.
+ *
+ * No scalar `strength` field in v0. Strength is computed lazily by
+ * an aggregator that may evolve as data accumulates.
+ */
+export declare const EvidenceSetSchema: z.ZodObject<{
+    id: z.ZodString;
+    claim_id: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        source_id: z.ZodString;
+        relation: z.ZodEnum<["supports", "contradicts", "contextualizes"]>;
+        quality: z.ZodEnum<["direct_observation", "tool_result", "human_assertion", "model_inference", "external_document", "synthetic_probe"]>;
+        independence_group: z.ZodOptional<z.ZodString>;
+        freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        relation: "supports" | "contradicts" | "contextualizes";
+        source_id: string;
+        quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+        freshness: "unknown" | "fresh" | "stale";
+        independence_group?: string | undefined;
+        notes?: string | undefined;
+    }, {
+        relation: "supports" | "contradicts" | "contextualizes";
+        source_id: string;
+        quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+        freshness: "unknown" | "fresh" | "stale";
+        independence_group?: string | undefined;
+        notes?: string | undefined;
+    }>, "many">;
+    assessed_by: z.ZodString;
+    assessed_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    claim_id: string;
+    items: {
+        relation: "supports" | "contradicts" | "contextualizes";
+        source_id: string;
+        quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+        freshness: "unknown" | "fresh" | "stale";
+        independence_group?: string | undefined;
+        notes?: string | undefined;
+    }[];
+    assessed_by: string;
+    assessed_at: string;
+}, {
+    id: string;
+    claim_id: string;
+    items: {
+        relation: "supports" | "contradicts" | "contextualizes";
+        source_id: string;
+        quality: "direct_observation" | "tool_result" | "human_assertion" | "model_inference" | "external_document" | "synthetic_probe";
+        freshness: "unknown" | "fresh" | "stale";
+        independence_group?: string | undefined;
+        notes?: string | undefined;
+    }[];
+    assessed_by: string;
+    assessed_at: string;
+}>;
+export type EvidenceSet = z.infer<typeof EvidenceSetSchema>;
+//# sourceMappingURL=claim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","sourceRoot":"","sources":["../../src/schemas/claim.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;GAEG;AACH,eAAO,MAAM,sBAAsB,+CAA6C,CAAA;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;GAEG;AACH,eAAO,MAAM,iBAAiB,+DAA6D,CAAA;AAC3F,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAatB,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAM/C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,gIAOhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schemas/claim.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { PredicateSchema, ResourceScopeSchema, SensitivitySchema, TimestampSchema } from "./common";
+/**
+ * How a claim was extracted from observation(s).
+ */
+export const ExtractionMethodSchema = z.enum(["tool", "llm", "human", "import"]);
+/**
+ * Lifecycle of a claim before it becomes a belief.
+ */
+export const ClaimStatusSchema = z.enum(["extracted", "contested", "accepted", "rejected"]);
+/**
+ * Dissent recorded against a claim. Reserved for multi-agent futures;
+ * v0 captures it but the resolution algorithm is deferred.
+ */
+export const DissentSchema = z.object({
+    by_actor_id: z.string(),
+    reason: z.string(),
+    at: TimestampSchema,
+});
+/**
+ * A statement extracted from one or more observations.
+ *
+ * Claims are the second link in the epistemic chain. Every claim
+ * records its extraction method and the actor that extracted it,
+ * so the source of an eventual belief can always be traced back to
+ * the original observation(s).
+ */
+export const ClaimSchema = z.object({
+    id: z.string(),
+    statement: z.string().describe("human-readable claim"),
+    structured_predicate: PredicateSchema.optional().describe("for queryable claims"),
+    source_observation_ids: z.array(z.string()).min(1, "a claim must reference at least one observation"),
+    extraction_method: ExtractionMethodSchema,
+    extracted_by: z.string().describe("actor_id of the extractor"),
+    status: ClaimStatusSchema,
+    scope: ResourceScopeSchema,
+    sensitivity: SensitivitySchema,
+    authors: z.array(z.string()).describe("actor_ids; usually one in v0, multi for v1.5+"),
+    dissent: z.array(DissentSchema).optional(),
+    created_at: TimestampSchema,
+});
+// -----------------------------------------------------------------------------
+// Evidence
+// -----------------------------------------------------------------------------
+/**
+ * Quality of a single piece of evidence.
+ *
+ * v0 uses a categorical taxonomy. A scalar evidence strength is
+ * deferred to later versions once enough data exists to calibrate
+ * a scoring function.
+ */
+export const EvidenceQualitySchema = z.enum([
+    "direct_observation", // tool output describing world state
+    "tool_result", // computed result from a tool
+    "human_assertion", // user said so
+    "model_inference", // an LLM concluded so from other context
+    "external_document", // file, webpage, email — high risk for poisoning
+    "synthetic_probe", // from a Harness probe; never affects real beliefs
+]);
+/**
+ * One piece of evidence for or against a claim.
+ *
+ * `independence_group` is used by aggregators: items in the same group
+ * are NOT independent. This matters because three citations to the same
+ * source are not three independent supporting items.
+ */
+export const EvidenceItemSchema = z.object({
+    source_id: z.string().describe("observation_id, belief_id, or external ref"),
+    relation: z.enum(["supports", "contradicts", "contextualizes"]),
+    quality: EvidenceQualitySchema,
+    independence_group: z.string().optional(),
+    freshness: z.enum(["fresh", "stale", "unknown"]),
+    notes: z.string().optional(),
+});
+/**
+ * Set of evidence assessed against a claim.
+ *
+ * No scalar `strength` field in v0. Strength is computed lazily by
+ * an aggregator that may evolve as data accumulates.
+ */
+export const EvidenceSetSchema = z.object({
+    id: z.string(),
+    claim_id: z.string(),
+    items: z.array(EvidenceItemSchema),
+    assessed_by: z.string().describe("actor_id of the assessor"),
+    assessed_at: TimestampSchema,
+});
+//# sourceMappingURL=claim.js.map

package/dist/schemas/claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.js","sourceRoot":"","sources":["../../src/schemas/claim.ts"],"names":[],"mappings":"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"}

package/dist/schemas/common.d.ts

@@ -0,0 +1,73 @@
+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 declare const SensitivitySchema: z.ZodEnum<["public", "internal", "confidential", "secret"]>;
+export type Sensitivity = z.infer<typeof SensitivitySchema>;
+/**
+ * Scope a claim, belief, memory, or action applies to. Hierarchical
+ * from broadest (global) to narrowest (session).
+ */
+export declare const ResourceScopeSchema: z.ZodObject<{
+    level: z.ZodEnum<["global", "organization", "user", "project", "repo", "session"]>;
+    identifier: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    level: "global" | "organization" | "user" | "project" | "repo" | "session";
+    identifier: string;
+}, {
+    level: "global" | "organization" | "user" | "project" | "repo" | "session";
+    identifier: string;
+}>;
+export type ResourceScope = z.infer<typeof ResourceScopeSchema>;
+/**
+ * Structured predicate for queryable claims and beliefs.
+ * Free-form for v0; refined in later versions as the planner matures.
+ */
+export declare const PredicateSchema: z.ZodObject<{
+    subject: z.ZodString;
+    relation: z.ZodString;
+    object: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    subject: string;
+    relation: string;
+    object?: unknown;
+}, {
+    subject: string;
+    relation: string;
+    object?: unknown;
+}>;
+export type Predicate = z.infer<typeof PredicateSchema>;
+/**
+ * ISO 8601 timestamp string.
+ */
+export declare const TimestampSchema: z.ZodString;
+export type Timestamp = z.infer<typeof TimestampSchema>;
+/**
+ * ISO 8601 duration string (e.g. "P30D", "PT1H").
+ */
+export declare const DurationSchema: z.ZodString;
+export type Duration = z.infer<typeof DurationSchema>;
+/**
+ * Generic Source reference used in evidence and explanations.
+ * Points to an observation, belief, or external identifier.
+ */
+export declare const SourceSchema: z.ZodObject<{
+    type: z.ZodEnum<["observation", "belief", "claim", "memory", "skill", "external"]>;
+    id: z.ZodString;
+    uri: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "observation" | "belief" | "claim" | "memory" | "skill" | "external";
+    id: string;
+    uri?: string | undefined;
+}, {
+    type: "observation" | "belief" | "claim" | "memory" | "skill" | "external";
+    id: string;
+    uri?: string | undefined;
+}>;
+export type Source = z.infer<typeof SourceSchema>;
+//# sourceMappingURL=common.d.ts.map