@davesheffer/hunch 1.32.8 → 1.35.0

package/dist/core/types.d.ts

@@ -7,7 +7,7 @@
  */
 import { z } from "zod";
 import { ProvenanceSchema, isCredentialFreeText, type Provenance } from "./provenance.js";
-import { type ActionReceipt, type Commitment, type DerivedState, type ExternalEntity, type StateRelationship } from "./stateRecords.js";
+import { type Convention, type ActionReceipt, type Commitment, type DerivedState, type ExternalEntity, type StateRelationship } from "./stateRecords.js";
 export { ProvenanceSchema, isCredentialFreeText };
 export type { Provenance };
 export declare const ComponentKind: z.ZodEnum<{
@@ -335,6 +335,11 @@ export declare const PremiseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type Premise = z.infer<typeof PremiseSchema>;
 export declare const DecisionSchema: z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        readers: z.ZodArray<z.ZodString>;
+        writers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     id: z.ZodString;
     title: z.ZodString;
     topic: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -416,6 +421,11 @@ export declare const BugLineageSchema: z.ZodObject<{
 export type BugLineage = z.infer<typeof BugLineageSchema>;
 /** A bug with root cause and lineage (introduced → fixed → recurred). */
 export declare const BugSchema: z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        readers: z.ZodArray<z.ZodString>;
+        writers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     id: z.ZodString;
     title: z.ZodString;
     symptom: z.ZodDefault<z.ZodString>;
@@ -452,6 +462,11 @@ export declare const BugSchema: z.ZodObject<{
 export type Bug = z.infer<typeof BugSchema>;
 /** An invariant the system must respect. */
 export declare const ConstraintSchema: z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        readers: z.ZodArray<z.ZodString>;
+        writers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     id: z.ZodString;
     type: z.ZodDefault<z.ZodEnum<{
         security: "security";
@@ -526,6 +541,11 @@ export type Runbook = z.infer<typeof RunbookSchema>;
  *  never enters any block path. Lifecycle is `triage`, not valid-time: a finding is
  *  resolved/stale-marked, never superseded. */
 export declare const FindingSchema: z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        readers: z.ZodArray<z.ZodString>;
+        writers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
     id: z.ZodString;
     title: z.ZodString;
     observation: z.ZodDefault<z.ZodString>;
@@ -538,8 +558,8 @@ export declare const FindingSchema: z.ZodObject<{
         critical: "critical";
     }>>;
     triage: z.ZodDefault<z.ZodEnum<{
-        open: "open";
         stale: "stale";
+        open: "open";
         "accepted-risk": "accepted-risk";
         scheduled: "scheduled";
         resolved: "resolved";
@@ -558,6 +578,96 @@ export declare const FindingSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Finding = z.infer<typeof FindingSchema>;
+/** A finished agent task as durable graph memory: what Hunch delivered, what the
+ * agent says it applied, what it saved and checked, and which files it touched.
+ * Written automatically when a task finishes with at least one observation; the
+ * raw observation ledger (.hunch-cache/served.db) stays machine-local. Titles are
+ * the only prose; no prompt text, transcript, or private context payload is kept. */
+export declare const TaskRecordSchema: z.ZodObject<{
+    visibility: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        readers: z.ZodArray<z.ZodString>;
+        writers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    title: z.ZodString;
+    state: z.ZodEnum<{
+        completed: "completed";
+        interrupted: "interrupted";
+    }>;
+    started_at: z.ZodString;
+    finished_at: z.ZodString;
+    coverage: z.ZodEnum<{
+        "no-delivery-observed": "no-delivery-observed";
+        "no-relevant-memory": "no-relevant-memory";
+        delivered: "delivered";
+    }>;
+    lessons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        record_id: z.ZodString;
+        content_hash: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>>;
+    applied: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        record_id: z.ZodString;
+        content_hash: z.ZodString;
+        action: z.ZodString;
+        supported_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    saved: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        record_id: z.ZodString;
+        content_hash: z.ZodString;
+        home: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        operation: z.ZodEnum<{
+            updated: "updated";
+            created: "created";
+        }>;
+        durability: z.ZodEnum<{
+            local: "local";
+            committed: "committed";
+            pushed: "pushed";
+        }>;
+    }, z.core.$strip>>>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        state: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            cancelled: "cancelled";
+            "timed out": "timed out";
+        }>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    conformance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            decisions: "decisions";
+            constraints: "constraints";
+        }>;
+        record_id: z.ZodString;
+        content_hash: z.ZodString;
+        outcome: z.ZodEnum<{
+            satisfied: "satisfied";
+            violated: "violated";
+            "not-exercised": "not-exercised";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strip>>>;
+    refusals: z.ZodDefault<z.ZodNumber>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    source_snapshot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    report_hash: z.ZodString;
+    provenance: z.ZodObject<{
+        source: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        last_verified: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TaskRecord = z.infer<typeof TaskRecordSchema>;
 export declare const LANDSCAPE_DRIFT_CANDIDATE_SCHEMA_VERSION: "hunch.landscape-drift-candidate/1";
 /**
  * An external observer's content-addressed mismatch claim. It is intake evidence
@@ -590,7 +700,7 @@ export declare function assertLandscapeDriftCandidate(value: unknown): asserts v
 /** Convert one valid external observation into advisory Hunch memory, never graph authority. */
 export declare function landscapeDriftCandidateFinding(value: unknown): Finding;
 /** The entity collections, keyed by their on-disk directory name. */
-export declare const ENTITY_KINDS: readonly ["components", "resources", "edges", "symbols", "decisions", "bugs", "constraints", "runbooks", "findings", "receipts", "commitments", "derived", "entities", "relationships"];
+export declare const ENTITY_KINDS: readonly ["components", "resources", "edges", "symbols", "decisions", "bugs", "constraints", "runbooks", "findings", "receipts", "commitments", "derived", "entities", "relationships", "conventions", "tasks"];
 export type EntityKind = (typeof ENTITY_KINDS)[number];
 export declare const SCHEMAS: {
     readonly components: z.ZodObject<{
@@ -753,6 +863,11 @@ export declare const SCHEMAS: {
         last_changed: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
     readonly decisions: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         id: z.ZodString;
         title: z.ZodString;
         topic: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -823,6 +938,11 @@ export declare const SCHEMAS: {
         date: z.ZodString;
     }, z.core.$strip>;
     readonly bugs: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         id: z.ZodString;
         title: z.ZodString;
         symptom: z.ZodDefault<z.ZodString>;
@@ -857,6 +977,11 @@ export declare const SCHEMAS: {
         }, z.core.$strip>;
     }, z.core.$strip>;
     readonly constraints: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         id: z.ZodString;
         type: z.ZodDefault<z.ZodEnum<{
             security: "security";
@@ -919,6 +1044,11 @@ export declare const SCHEMAS: {
         date: z.ZodString;
     }, z.core.$strip>;
     readonly findings: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         id: z.ZodString;
         title: z.ZodString;
         observation: z.ZodDefault<z.ZodString>;
@@ -931,8 +1061,8 @@ export declare const SCHEMAS: {
             critical: "critical";
         }>>;
         triage: z.ZodDefault<z.ZodEnum<{
-            open: "open";
             stale: "stale";
+            open: "open";
             "accepted-risk": "accepted-risk";
             scheduled: "scheduled";
             resolved: "resolved";
@@ -950,7 +1080,76 @@ export declare const SCHEMAS: {
             last_verified: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    readonly conventions: z.ZodObject<{
+        schema: z.ZodLiteral<"nuryel.convention/1">;
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        key: z.ZodString;
+        value: z.ZodString;
+        status: z.ZodEnum<{
+            stale: "stale";
+            proposed: "proposed";
+            accepted: "accepted";
+            withdrawn: "withdrawn";
+        }>;
+        sources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            ref: z.ZodObject<{
+                system: z.ZodString;
+                object_type: z.ZodString;
+                object_key: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                content_hash: z.ZodOptional<z.ZodString>;
+                observed_at: z.ZodString;
+                locator: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            name: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        valid_from: z.ZodString;
+        valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        review_by: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
     readonly receipts: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         schema: z.ZodLiteral<"nuryel.receipt/1">;
         id: z.ZodString;
         scope: z.ZodObject<{
@@ -1023,6 +1222,11 @@ export declare const SCHEMAS: {
         }, z.core.$strip>;
     }, z.core.$strict>;
     readonly commitments: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         schema: z.ZodLiteral<"nuryel.commitment/1">;
         id: z.ZodString;
         scope: z.ZodObject<{
@@ -1065,6 +1269,11 @@ export declare const SCHEMAS: {
         }, z.core.$strip>;
     }, z.core.$strict>;
     readonly derived: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         schema: z.ZodLiteral<"nuryel.derived/1">;
         id: z.ZodString;
         scope: z.ZodObject<{
@@ -1108,6 +1317,18 @@ export declare const SCHEMAS: {
             name: z.ZodString;
             fingerprint: z.ZodString;
         }, z.core.$strict>], "kind">>;
+        field_provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"json_pointer">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+            value_hash: z.ZodString;
+            dependency_hashes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
         transform_version: z.ZodString;
         computed_at: z.ZodString;
         valid_to: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -1142,6 +1363,11 @@ export declare const SCHEMAS: {
         }, z.core.$strip>;
     }, z.core.$strict>;
     readonly entities: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         schema: z.ZodLiteral<"nuryel.entity/1">;
         id: z.ZodString;
         kind: z.ZodString;
@@ -1181,6 +1407,11 @@ export declare const SCHEMAS: {
         updated_at: z.ZodString;
     }, z.core.$strict>;
     readonly relationships: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
         schema: z.ZodLiteral<"nuryel.relationship/1">;
         id: z.ZodString;
         from: z.ZodString;
@@ -1217,6 +1448,90 @@ export declare const SCHEMAS: {
             last_verified: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strict>;
+    readonly tasks: z.ZodObject<{
+        visibility: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            readers: z.ZodArray<z.ZodString>;
+            writers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodEnum<{
+            completed: "completed";
+            interrupted: "interrupted";
+        }>;
+        started_at: z.ZodString;
+        finished_at: z.ZodString;
+        coverage: z.ZodEnum<{
+            "no-delivery-observed": "no-delivery-observed";
+            "no-relevant-memory": "no-relevant-memory";
+            delivered: "delivered";
+        }>;
+        lessons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            record_id: z.ZodString;
+            content_hash: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>>;
+        applied: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            record_id: z.ZodString;
+            content_hash: z.ZodString;
+            action: z.ZodString;
+            supported_by: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        saved: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            record_id: z.ZodString;
+            content_hash: z.ZodString;
+            home: z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>;
+            operation: z.ZodEnum<{
+                updated: "updated";
+                created: "created";
+            }>;
+            durability: z.ZodEnum<{
+                local: "local";
+                committed: "committed";
+                pushed: "pushed";
+            }>;
+        }, z.core.$strip>>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            state: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                cancelled: "cancelled";
+                "timed out": "timed out";
+            }>;
+            exit_code: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        conformance: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                decisions: "decisions";
+                constraints: "constraints";
+            }>;
+            record_id: z.ZodString;
+            content_hash: z.ZodString;
+            outcome: z.ZodEnum<{
+                satisfied: "satisfied";
+                violated: "violated";
+                "not-exercised": "not-exercised";
+                unavailable: "unavailable";
+            }>;
+        }, z.core.$strip>>>;
+        refusals: z.ZodDefault<z.ZodNumber>;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        source_snapshot: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        report_hash: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodString;
+            confidence: z.ZodNumber;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            last_verified: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
 };
 export type EntityFor = {
     components: Component;
@@ -1228,11 +1543,13 @@ export type EntityFor = {
     constraints: Constraint;
     runbooks: Runbook;
     findings: Finding;
+    conventions: Convention;
     receipts: ActionReceipt;
     commitments: Commitment;
     derived: DerivedState;
     entities: ExternalEntity;
     relationships: StateRelationship;
+    tasks: TaskRecord;
 };
 /** Default provenance helper for deterministic (extracted) records. */
 export declare function extracted(confidence: number, evidence?: string[]): Provenance;

package/dist/core/types.js

@@ -1,3 +1,4 @@
+import { RecordVisibilitySchema } from "./recordVisibility.js";
 /**
  * Core entity schema for the Project Hunch (DESIGN.md §3).
  *
@@ -9,7 +10,7 @@ import { z } from "zod";
 import { createHash } from "node:crypto";
 import { findingId, resourceId, resourceRelationshipId } from "./ids.js";
 import { ProvenanceSchema, SENSITIVE_METADATA_KEY, isCredentialFreeText } from "./provenance.js";
-import { ActionReceiptSchema, CommitmentSchema, DerivedStateSchema, ExternalEntitySchema, StateRelationshipSchema, } from "./stateRecords.js";
+import { ConventionSchema, ActionReceiptSchema, CommitmentSchema, DerivedStateSchema, ExternalEntitySchema, StateRelationshipSchema, } from "./stateRecords.js";
 // Provenance and the credential-free text check live in the leaf module ./provenance.js so
 // record schemas registered below can import them without a cycle; re-exported unchanged.
 export { ProvenanceSchema, isCredentialFreeText };
@@ -323,6 +324,7 @@ export const PremiseSchema = z.object({
     path: ["under"],
 });
 export const DecisionSchema = z.object({
+    visibility: RecordVisibilitySchema.optional(),
     id: z.string().describe("dec_*"),
     title: z.string(),
     // Decision-grounding anchor: the join key that relates a doc section, a decision,
@@ -372,6 +374,7 @@ export const BugLineageSchema = z.object({
 });
 /** A bug with root cause and lineage (introduced → fixed → recurred). */
 export const BugSchema = z.object({
+    visibility: RecordVisibilitySchema.optional(),
     id: z.string().describe("bug_*"),
     title: z.string(),
     symptom: z.string().default(""),
@@ -388,6 +391,7 @@ export const BugSchema = z.object({
 });
 /** An invariant the system must respect. */
 export const ConstraintSchema = z.object({
+    visibility: RecordVisibilitySchema.optional(),
     id: z.string().describe("con_*"),
     type: z.enum(["security", "performance", "correctness", "architecture", "compliance"]).default("correctness"),
     statement: z.string(),
@@ -448,6 +452,7 @@ export const RunbookSchema = z.object({
  *  never enters any block path. Lifecycle is `triage`, not valid-time: a finding is
  *  resolved/stale-marked, never superseded. */
 export const FindingSchema = z.object({
+    visibility: RecordVisibilitySchema.optional(),
     id: z.string().describe("fnd_*"),
     title: z.string(),
     observation: z.string().default("").describe("what was observed, in plain words"),
@@ -463,6 +468,44 @@ export const FindingSchema = z.object({
     resolved_commit: z.string().nullable().default(null).describe("the commit that fixed it (set when triage becomes resolved)"),
     provenance: ProvenanceSchema,
 });
+/** A finished agent task as durable graph memory: what Hunch delivered, what the
+ * agent says it applied, what it saved and checked, and which files it touched.
+ * Written automatically when a task finishes with at least one observation; the
+ * raw observation ledger (.hunch-cache/served.db) stays machine-local. Titles are
+ * the only prose; no prompt text, transcript, or private context payload is kept. */
+export const TaskRecordSchema = z.object({
+    visibility: RecordVisibilitySchema.optional(),
+    id: z.string().describe("htask_*"),
+    title: z.string(),
+    state: z.enum(["completed", "interrupted"]),
+    started_at: z.string(),
+    finished_at: z.string(),
+    coverage: z.enum(["no-delivery-observed", "no-relevant-memory", "delivered"]),
+    lessons: z.array(z.object({
+        kind: z.string(), record_id: z.string(), content_hash: z.string(), title: z.string(),
+    })).default([]).describe("exact record revisions Hunch delivered to the agent"),
+    applied: z.array(z.object({
+        record_id: z.string(), content_hash: z.string(), action: z.string(),
+        supported_by: z.string().nullable().default(null),
+    })).default([]).describe("agent-reported applications; supported_by names Hunch's own rule evaluation when one held"),
+    saved: z.array(z.object({
+        kind: z.string(), record_id: z.string(), content_hash: z.string(),
+        home: z.enum(["public", "private"]), operation: z.enum(["created", "updated"]),
+        durability: z.enum(["local", "committed", "pushed"]),
+    })).default([]).describe("memory the task wrote, with its actual home and proven durability"),
+    checks: z.array(z.object({
+        label: z.string(), state: z.enum(["passed", "failed", "timed out", "cancelled"]), exit_code: z.number().int().nullable(),
+    })).default([]).describe("independently observed command results (hunch task verify)"),
+    conformance: z.array(z.object({
+        kind: z.enum(["constraints", "decisions"]), record_id: z.string(), content_hash: z.string(),
+        outcome: z.enum(["satisfied", "violated", "not-exercised", "unavailable"]),
+    })).default([]).describe("Hunch's deterministic evaluation of each delivered rule against the changed files"),
+    refusals: z.number().int().nonnegative().default(0).describe("edits the native gate denied during the task"),
+    files: z.array(z.string()).default([]).describe("files the task touched: delivery targets, rule-checked changes, denied edits"),
+    source_snapshot: z.string().nullable().default(null).describe("bounded source snapshot hash at the last check, when one ran"),
+    report_hash: z.string().describe("content hash of the full local report this record summarizes"),
+    provenance: ProvenanceSchema,
+});
 export const LANDSCAPE_DRIFT_CANDIDATE_SCHEMA_VERSION = "hunch.landscape-drift-candidate/1";
 const LANDSCAPE_DRIFT_HASH = /^sha256:[a-f0-9]{64}$/;
 const LANDSCAPE_DRIFT_RECEIPT_ID = /^[a-z][a-z0-9_:-]{2,127}$/;
@@ -594,7 +637,7 @@ export function landscapeDriftCandidateFinding(value) {
 // loads exactly as before, and an older build ignores directories it does not know.
 export const ENTITY_KINDS = [
     "components", "resources", "edges", "symbols", "decisions", "bugs", "constraints", "runbooks", "findings",
-    "receipts", "commitments", "derived", "entities", "relationships",
+    "receipts", "commitments", "derived", "entities", "relationships", "conventions", "tasks",
 ];
 export const SCHEMAS = {
     components: ComponentSchema,
@@ -606,11 +649,13 @@ export const SCHEMAS = {
     constraints: ConstraintSchema,
     runbooks: RunbookSchema,
     findings: FindingSchema,
+    conventions: ConventionSchema,
     receipts: ActionReceiptSchema,
     commitments: CommitmentSchema,
     derived: DerivedStateSchema,
     entities: ExternalEntitySchema,
     relationships: StateRelationshipSchema,
+    tasks: TaskRecordSchema,
 };
 /** Default provenance helper for deterministic (extracted) records. */
 export function extracted(confidence, evidence = []) {

package/dist/core/updatecheck.d.ts

@@ -0,0 +1,51 @@
+/** Best-effort update notices for interactive CLI commands.
+ *
+ * The foreground process only reads a small cache and starts an unreferenced,
+ * detached worker when that cache is stale. Network I/O happens in the worker,
+ * so an unavailable registry cannot hold the user's command open. The first
+ * cold invocation populates the cache; later invocations can display it.
+ */
+import { spawn } from "node:child_process";
+export interface UpdateCheckResult {
+    current: string;
+    latest: string;
+}
+export interface UpdateCachePathOptions {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    platform?: NodeJS.Platform;
+}
+/** Use each platform's normal per-user cache root. This deliberately never
+ * creates a `.hunch` path segment: `.hunch` is the repository marker used by
+ * findRoot(), so placing a cache there could redirect commands to the wrong
+ * project. */
+export declare function defaultCacheFile(opts?: UpdateCachePathOptions): string;
+/** Full SemVer precedence for the release and prerelease fields. */
+export declare function isNewerVersion(candidate: string, current: string): boolean;
+export interface RefreshUpdateCacheOptions {
+    cacheFile?: string;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}
+/** Worker entry point, exported so network/cache behavior is testable without
+ * spawning a process or contacting the real registry. */
+export declare function refreshUpdateCache(opts?: RefreshUpdateCacheOptions): Promise<boolean>;
+export interface ScheduleUpdateCheckOptions {
+    cacheFile?: string;
+    currentVersion?: string;
+    now?: () => number;
+    workerFile?: string;
+    spawnImpl?: typeof spawn;
+}
+/** Read any known update immediately and schedule at most one refresh per day.
+ * Claiming the interval before spawning also bounds offline requests: failed
+ * checks are not retried on every CLI command. */
+export declare function scheduleUpdateCheck(opts?: ScheduleUpdateCheckOptions): UpdateCheckResult | null;
+export interface UpdateCheckGateOptions {
+    commandName: string;
+    isTTY: boolean;
+    installed: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function shouldCheckForUpdate({ commandName, isTTY, installed, env }: UpdateCheckGateOptions): boolean;
+export declare function formatUpdateNotice(result: UpdateCheckResult): string;