@clossys/butler 0.1.1

package/dist/schema.d.ts

@@ -0,0 +1,374 @@
+/**
+ * The want contract: what a person asked for right now, and what they told
+ * us to keep doing.
+ *
+ * Two record families live here and they are deliberately not merged. An
+ * INTENT is a single request, interpreted, carrying a confidence, and true
+ * only until it has been acted on. A STANDING INSTRUCTION is a durable
+ * answer that keeps speaking for the person until it expires or the policy
+ * it answered is superseded. Both are consumer-authored data; nothing in
+ * this package ships a value, a topic vocabulary, a jurisdiction rule, or
+ * an obligation of its own.
+ *
+ * THE THREE-STATE MODEL, PRESERVED
+ * ---------------------------------
+ * `StandingState` is three states, not two. `"absent"` (never asked) is a
+ * distinct value from `"denied"` (asked, refused), and neither is a
+ * boolean. Collapsing them would make "never asked" indistinguishable from
+ * a passing signal — the same absence-of-signal-looks-like-a-passing-signal
+ * failure this repository already writes down for gate exit codes (see
+ * this repository's own contribution guide, "Gate CLIs exit `0` clean,
+ * `1` findings, `2` could not run"). `"granted"` and `"denied"` each carry
+ * the policy version they answered and when; a bare boolean can carry
+ * neither, which is exactly what turns a stored answer into an unauditable
+ * guess instead of a record.
+ *
+ * A fourth value, `"stale"`, exists only as an EVALUATION status
+ * (`StandingEvaluation`), never as a stored state — staleness is computed
+ * by comparing a stored record against the policy in force and the clock,
+ * so writing it down would be storing a derivation that starts rotting the
+ * moment it is written.
+ *
+ * IDENTIFIERS
+ * ------------
+ * `subjectId` is the person the want belongs to; `actorId` is whoever or
+ * whatever is acting. They are separate fields in every signature in this
+ * package and are never unified, because "the system acted on its own
+ * reading" and "the person asked for this" are the two things this whole
+ * package exists to keep apart. Both are opaque host-owned references —
+ * never an email address, a name, a phone number, or an IP. See
+ * `audit-shape.check.ts` for the compile-time proof that the audit event
+ * carries nothing else.
+ *
+ * Validation here is hand-rolled over `unknown`, with no schema library,
+ * matching every other package in this workspace (see the root
+ * `AGENTS.md`). These validators exist for the boundary where records
+ * arrive as untyped JSON — a preference-centre route body, a file the CLI
+ * reads, a value read back out of a host's own store — before anything
+ * downstream is allowed to trust them.
+ */
+import { type ValidationResult } from "./validation.js";
+/**
+ * Identifies which version of a policy document a record answers. A
+ * standing instruction that cannot name what it answered cannot be shown
+ * to have gone stale.
+ */
+export interface PolicyVersion {
+    policyId: string;
+    version: string;
+}
+/**
+ * Consumer-defined; this package does not enumerate topics. A topic is
+ * whatever a consumer's own policy defines ("marketing-email",
+ * "contact-window", "language", ...) — nothing here needs it to be more
+ * than a stable string used to key one subject's standing instructions.
+ */
+export type StandingTopic = string;
+/**
+ * Where a standing instruction came from. `"stated"` is the person's own
+ * words. `"inferred"` is a reading of their behaviour, and an inferred
+ * instruction is NEVER binding until they confirm it — see
+ * `evaluateStandingInstruction` (`contract.ts`), which reports an
+ * unconfirmed inference as `absent`, because an unconfirmed guess is not a
+ * want we have.
+ */
+export type StandingProvenance = "stated" | "inferred";
+/** Every provenance value, for a caller validating untyped input. */
+export declare const STANDING_PROVENANCES: readonly StandingProvenance[];
+/**
+ * How long a stored answer keeps speaking for the person. Consumer-declared
+ * per instruction, with NO default anywhere in this package: a window this
+ * package invented would be this package authoring one of the consumer's
+ * values, and a missing window silently read as "forever" is precisely the
+ * open loop the currency gate exists to close.
+ */
+export interface CurrencyWindow {
+    /** Whole days after `decidedAt` during which the answer is still current. */
+    days: number;
+}
+/**
+ * Three states, not two. See this file's header for why `"absent"` is a
+ * value rather than the absence of one, and why neither `"granted"` nor
+ * `"denied"` is a boolean.
+ */
+export type StandingState = {
+    kind: "absent";
+} | {
+    kind: "denied";
+    policyVersion: PolicyVersion;
+    decidedAt: string;
+} | {
+    kind: "granted";
+    policyVersion: PolicyVersion;
+    decidedAt: string;
+};
+/** One durable answer, for one subject, on one topic. */
+export interface StandingInstruction {
+    /** Stable, host-owned id for this instruction. The currency gate joins usages to instructions on it. */
+    instructionId: string;
+    /** Host-owned identity reference — an opaque id, never raw personal data. */
+    subjectId: string;
+    topic: StandingTopic;
+    state: StandingState;
+    provenance: StandingProvenance;
+    currency: CurrencyWindow;
+    /** When the subject confirmed an INFERRED instruction. Absent on an unconfirmed inference; meaningless (and ignored) on a `"stated"` one. */
+    confirmedAt?: string;
+}
+/**
+ * The result of comparing a stored instruction against the policy in force
+ * and the clock. `"stale"` means a stored answer no longer speaks for the
+ * subject and they should be asked again; it carries WHY, because "the
+ * policy moved" and "the window ran out" are different facts about the
+ * same record and a consumer's re-ask copy will differ between them.
+ *
+ * `"absent"` likewise carries a reason. An unconfirmed inference and a
+ * subject who was genuinely never asked are both "we do not have a want
+ * here" — the same status, correctly — but they are not the same event,
+ * and flattening them would hide the more interesting of the two.
+ * `previousPolicyVersion` on a `"stale"` result is the version the stale
+ * answer actually answered, not the current one; `"granted"`/`"denied"`
+ * likewise report the version actually answered rather than echoing the
+ * caller's current version back.
+ */
+export type StandingEvaluation = {
+    status: "absent";
+    reason: "no-record" | "unconfirmed-inference";
+} | {
+    status: "stale";
+    reason: "policy-superseded" | "window-elapsed";
+    previousPolicyVersion: PolicyVersion;
+    decidedAt: string;
+} | {
+    status: "granted";
+    policyVersion: PolicyVersion;
+} | {
+    status: "denied";
+    policyVersion: PolicyVersion;
+};
+/**
+ * Governs whether a policy-version bump also invalidates a stored `denied`
+ * record. Left as a caller-supplied value with **no default** in either
+ * direction: whether a policy bump invalidates a prior refusal is a
+ * jurisdiction judgment, and this package answers no jurisdiction
+ * questions. A `granted` record always goes stale on a version bump
+ * regardless of this flag; only the `denied` case is caller-decided.
+ */
+export interface StandingEvaluationPolicy {
+    invalidateDenialOnPolicyBump: boolean;
+}
+/**
+ * The three things a subject can do to their own standing instruction.
+ * Every variant carries the `policyVersion` in force at the moment of the
+ * action — including `withdraw`, so an audit event never has to guess one
+ * or leave the field empty. There is no fourth, harder variant for
+ * withdrawing, and no variant an actor can use to decide FOR a subject.
+ */
+export type StandingAction = {
+    kind: "grant";
+    topic: StandingTopic;
+    policyVersion: PolicyVersion;
+    currency: CurrencyWindow;
+} | {
+    kind: "deny";
+    topic: StandingTopic;
+    policyVersion: PolicyVersion;
+    currency: CurrencyWindow;
+} | {
+    kind: "withdraw";
+    topic: StandingTopic;
+    policyVersion: PolicyVersion;
+    currency: CurrencyWindow;
+};
+/**
+ * `"reopened"` records that a subject reopened their preference surface —
+ * audit-worthy on its own, independent of whether they changed anything.
+ * `"policy-superseded"` and `"window-elapsed"` record that a stored answer
+ * was found stale, by a policy bump and by the clock respectively.
+ * `"confirmed"` and `"misread"` record the outcome of an intent read-back.
+ * None of the last four is emitted by `decideStandingChange`, which only
+ * ever emits `"granted"` / `"denied"` / `"withdrawn"`.
+ */
+export type StandingAuditEventType = "granted" | "denied" | "withdrawn" | "reopened" | "policy-superseded" | "window-elapsed" | "confirmed" | "misread";
+/** Every audit event type, for a caller validating untyped input. */
+export declare const STANDING_AUDIT_EVENT_TYPES: readonly StandingAuditEventType[];
+/**
+ * An audit trail entry. Deliberately carries no raw personal-data field —
+ * no email, no name, no phone, no address, no IP — only the opaque
+ * `subjectId` and the separately-opaque `actorId`. `topic` is a
+ * consumer-defined label, never itself personal data.
+ * `src/audit-shape.check.ts` is a compile-time contract test that fails the
+ * build if a personal-data-shaped key is ever added to this type.
+ *
+ * `previousPolicyVersion` is present only on a `"policy-superseded"` event;
+ * every other type's `policyVersion` fully describes which version the
+ * event pertains to on its own.
+ */
+export interface StandingAuditEvent {
+    /** The subject the want belongs to. */
+    subjectId: string;
+    /** Whoever or whatever performed the action. Separate from `subjectId`, always. */
+    actorId: string;
+    topic: StandingTopic;
+    type: StandingAuditEventType;
+    policyVersion: PolicyVersion;
+    occurredAt: string;
+    previousPolicyVersion?: PolicyVersion;
+}
+/**
+ * Host-implemented audit ledger. This package decides what an audit event
+ * contains; the host decides where it is durably recorded. No
+ * implementation of this interface ships here, and no person-attributable
+ * record is ever written into this repository.
+ */
+export interface StandingAuditLedger {
+    record(event: StandingAuditEvent): Promise<void>;
+}
+/**
+ * Host-implemented storage port. This package does not choose a database,
+ * a cookie, a session, or a file — that choice, and its durability
+ * guarantees, belongs entirely to the host, and no concrete implementation
+ * of this interface ships here.
+ */
+export interface StandingInstructionStore {
+    read(subjectId: string, topic: StandingTopic): Promise<StandingInstruction | undefined>;
+    write(instruction: StandingInstruction): Promise<void>;
+    readAll(subjectId: string): Promise<readonly StandingInstruction[]>;
+}
+/**
+ * What happened to an interpreted intent. `"acted"` means something was
+ * done in the world on the strength of this reading. `"handed-off"` means
+ * it was explicitly given to a person instead — the only legitimate exit
+ * for a reading the machine was not confident enough to act on.
+ * `"awaiting-confirmation"` means it is still waiting on the subject's own
+ * read-back and nothing has acted yet.
+ */
+export type IntentDisposition = "acted" | "handed-off" | "awaiting-confirmation";
+/** Every disposition, for a caller validating untyped input. */
+export declare const INTENT_DISPOSITIONS: readonly IntentDisposition[];
+/**
+ * One request, admitted on some channel and interpreted into a structured
+ * reading.
+ *
+ * `confidence` is a first-class value on the record, not an
+ * implementation detail left inside whichever model produced the reading:
+ * a number in `[0, 1]` that a gate can read months later and compare
+ * against the floor that was in force. `interpretation` is a
+ * consumer-defined label for what the reading concluded — this package
+ * never enumerates interpretations and never inspects the request text,
+ * which is why no field here holds it.
+ */
+export interface IntentRecord {
+    intentId: string;
+    /** The person whose want this is. */
+    subjectId: string;
+    /** Whoever or whatever produced and dispositioned this reading. Separate from `subjectId`, always. */
+    actorId: string;
+    /** Consumer-defined label for what the reading concluded. */
+    interpretation: string;
+    /** `0`–`1` inclusive. Read against a declared floor; never against a floor this package invented. */
+    confidence: number;
+    observedAt: string;
+    disposition: IntentDisposition;
+}
+/**
+ * The subject's own answer to a read-back. Three outcomes, not two:
+ * `"unclear"` is the person saying they cannot tell, which is a real,
+ * distinct answer and must never be rounded up into `"confirmed"`.
+ */
+export type ConfirmationVerdict = "confirmed" | "misread" | "unclear";
+/** Every verdict, for a caller validating untyped input. */
+export declare const CONFIRMATION_VERDICTS: readonly ConfirmationVerdict[];
+/** One read-back answered by the subject, naming the intent it answers. */
+export interface ConfirmationRecord {
+    intentId: string;
+    subjectId: string;
+    verdict: ConfirmationVerdict;
+    confirmedAt: string;
+}
+/**
+ * The declared confidence floor. Consumer-authored, with no default: this
+ * package will not invent the number below which a reading is too weak to
+ * act on, and a run that cannot find one refuses to run at all rather than
+ * assume one.
+ */
+export interface ConfidenceFloor {
+    /** `0`–`1` inclusive. A reading strictly below this may not be acted on silently. */
+    minimumConfidence: number;
+}
+/**
+ * One occasion on which a standing instruction was actually relied on.
+ * This is the observation half of the loop: an instruction that is written
+ * and never re-checked is an open loop, and a usage record is what closes
+ * it — the currency gate reads these, not the instructions alone.
+ *
+ * `currentPolicyVersion` is the version in force AT THE MOMENT OF USE, not
+ * today's; that is what makes this record replayable rather than a
+ * derivation that changes every time it is read.
+ */
+export interface InstructionUsage {
+    instructionId: string;
+    actorId: string;
+    usedAt: string;
+    currentPolicyVersion: PolicyVersion;
+}
+/**
+ * What one route through a consumer's own interface costs the person.
+ * Deliberately three coarse, countable facts rather than a score: a
+ * comparison that produces a number nobody can trace back to a step is not
+ * evidence of anything.
+ */
+export interface PathCost {
+    /** How many discrete actions the person takes, counted the same way on both sides of the comparison. */
+    steps: number;
+    /** Whether the route requires contacting a human (writing in, calling) rather than completing it themselves. */
+    requiresContact: boolean;
+    /** Whether the route requires an authenticated account. */
+    requiresAccount: boolean;
+}
+/**
+ * The grant route and the withdraw route for one topic on one surface,
+ * measured the same way, so "withdrawing is no harder than granting" stops
+ * being an assurance and becomes a comparison. `withdraw` is optional
+ * precisely so its ABSENCE is representable and reportable — a surface
+ * that offers no way out at all is the worst version of this defect, and a
+ * required field would have made it unsayable.
+ */
+export interface PreferencePath {
+    surfaceId: string;
+    topic: StandingTopic;
+    grant: PathCost;
+    withdraw?: PathCost;
+}
+/** Validates one untyped `StandingInstruction`. Never throws. */
+export declare function validateStandingInstruction(value: unknown): ValidationResult<StandingInstruction>;
+/** Validates an untyped array of `StandingInstruction`s. Never throws. */
+export declare function validateStandingInstructions(value: unknown): ValidationResult<StandingInstruction[]>;
+/** Validates one untyped `IntentRecord`. Never throws. */
+export declare function validateIntentRecord(value: unknown): ValidationResult<IntentRecord>;
+/** Validates an untyped array of `IntentRecord`s. Never throws. */
+export declare function validateIntentRecords(value: unknown): ValidationResult<IntentRecord[]>;
+/** Validates one untyped `ConfirmationRecord`. Never throws. */
+export declare function validateConfirmationRecord(value: unknown): ValidationResult<ConfirmationRecord>;
+/** Validates an untyped array of `ConfirmationRecord`s. Never throws. */
+export declare function validateConfirmationRecords(value: unknown): ValidationResult<ConfirmationRecord[]>;
+/** Validates an untyped array of `InstructionUsage`s. Never throws. */
+export declare function validateInstructionUsages(value: unknown): ValidationResult<InstructionUsage[]>;
+/** Validates an untyped array of `PreferencePath`s. Never throws. */
+export declare function validatePreferencePaths(value: unknown): ValidationResult<PreferencePath[]>;
+/**
+ * Validates an untyped `ConfidenceFloor`. Separate from the record
+ * validators because the floor is not a record: it is the one declared
+ * value the confirmation gate reads, and a run that cannot validate it
+ * must decline rather than substitute one.
+ */
+export declare function validateConfidenceFloor(value: unknown): ValidationResult<ConfidenceFloor>;
+/** Validates an untyped `PolicyVersion`. Never throws. */
+export declare function validatePolicyVersion(value: unknown): ValidationResult<PolicyVersion>;
+/** Convenience guard over `validateStandingInstruction`, for callers that only need the boolean answer at a type boundary. */
+export declare function isStandingInstruction(value: unknown): value is StandingInstruction;
+/** Convenience guard over `validateIntentRecord`. */
+export declare function isIntentRecord(value: unknown): value is IntentRecord;
+/** Convenience guard over `validateConfirmationRecord`. */
+export declare function isConfirmationRecord(value: unknown): value is ConfirmationRecord;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

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