pulseed 0.6.5 → 0.6.6

package/dist/runtime/types/companion-autonomy.js

@@ -0,0 +1,1091 @@
+import { z } from "zod";
+import { PermissionGrantCapabilitySchema, PermissionGrantExcludedCapabilitySchema, } from "../store/permission-grant-store.js";
+const CompanionAutonomyRefKinds = [
+    "runtime_item",
+    "runtime_event",
+    "runtime_control",
+    "observation_session",
+    "observation_event",
+    "surface",
+    "memory",
+    "memory_candidate",
+    "permission_grant",
+    "relationship_permission",
+    "approval",
+    "tool_call",
+    "conversation",
+    "goal",
+    "task",
+    "session",
+    "schedule_tick",
+    "wait",
+    "drive",
+    "curiosity",
+    "dream_artifact",
+    "soil_retrieval",
+    "correction",
+    "automation",
+    "guardrail",
+    "backpressure",
+    "user_activity",
+    "feedback",
+    "companion_state",
+    "signal_context",
+    "urge_candidate",
+    "agent_agenda_item",
+    "attention_cluster",
+    "agenda_decomposition",
+    "agenda_decomposition_child",
+    "attention_event",
+    "attention_cycle",
+    "attention_admission",
+    "inhibition_decision",
+    "initiative_gate_decision",
+    "outcome_decision",
+    "expression_decision",
+    "audit_trace",
+    "visibility_policy",
+    "authority_check",
+    "staleness_check",
+    "safety_check",
+    "control_policy",
+    "surface_update_candidate",
+    "action_candidate",
+    "digest",
+    "policy",
+];
+export const CompanionAutonomyRefKindSchema = z.enum(CompanionAutonomyRefKinds);
+export const CompanionAutonomyRefSchema = z.object({
+    kind: CompanionAutonomyRefKindSchema,
+    id: z.string().min(1),
+    version: z.string().min(1).optional(),
+}).strict();
+function refWithKind(...allowedKinds) {
+    return CompanionAutonomyRefSchema.refine((ref) => allowedKinds.includes(ref.kind), {
+        message: `ref kind must be one of: ${allowedKinds.join(", ")}`,
+    });
+}
+const AuditTraceRefSchema = refWithKind("audit_trace");
+const AgentAgendaRefSchema = refWithKind("agent_agenda_item");
+const AttentionClusterRefSchema = refWithKind("attention_cluster");
+const InitiativeGateDecisionRefSchema = refWithKind("initiative_gate_decision");
+const OutcomeDecisionRefSchema = refWithKind("outcome_decision");
+const UrgeCandidateRefSchema = refWithKind("urge_candidate");
+const VisibilityPolicyRefSchema = refWithKind("visibility_policy");
+export const CompanionAutonomyContentLifecycleSchema = z.enum([
+    "active",
+    "redacted",
+    "tombstone",
+    "deleted",
+]);
+export const CompanionAutonomySourceRefSchema = z.object({
+    ref: CompanionAutonomyRefSchema,
+    lifecycle: CompanionAutonomyContentLifecycleSchema.default("active"),
+    redaction_reason: z.string().min(1).optional(),
+}).strict();
+export const AttentionPrioritySchema = z.enum(["low", "normal", "high", "critical"]);
+export const AttentionRiskLevelSchema = z.enum(["none", "low", "medium", "high", "critical"]);
+export const AttentionRiskAssessmentSchema = z.object({
+    level: AttentionRiskLevelSchema,
+    reason: z.string().min(1),
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+}).strict();
+export const AttentionSensitivitySchema = z.enum([
+    "public",
+    "internal",
+    "sensitive",
+    "restricted",
+]);
+export const AttentionSurfaceClassSchema = z.enum([
+    "cli",
+    "tui",
+    "telegram",
+    "daemon",
+    "schedule",
+    "system",
+    "unknown",
+]);
+export const AttentionPermissionScopeSchema = z.enum([
+    "local_only",
+    "read_only",
+    "draft_allowed",
+    "notify_allowed",
+    "write_allowed",
+    "unknown",
+]);
+export const AttentionScopeSensitivitySchema = z.enum([
+    "low",
+    "medium",
+    "high",
+    "unknown",
+]);
+export const DEFAULT_ATTENTION_SCOPE = {
+    userId: null,
+    identityId: null,
+    workspaceId: null,
+    conversationId: null,
+    sessionId: null,
+    surfaceClass: "unknown",
+    surfaceRef: null,
+    permissionScope: "unknown",
+    sensitivity: "unknown",
+    memoryOwner: null,
+    policyEpoch: "unknown",
+};
+export const AttentionScopeSchema = z.object({
+    userId: z.string().min(1).nullable(),
+    identityId: z.string().min(1).nullable().optional(),
+    workspaceId: z.string().min(1).nullable().optional(),
+    conversationId: z.string().min(1).nullable().optional(),
+    sessionId: z.string().min(1).nullable().optional(),
+    surfaceClass: AttentionSurfaceClassSchema,
+    surfaceRef: z.string().min(1).nullable().optional(),
+    permissionScope: AttentionPermissionScopeSchema,
+    sensitivity: AttentionScopeSensitivitySchema,
+    memoryOwner: z.string().min(1).nullable().optional(),
+    policyEpoch: z.string().min(1),
+}).strict();
+export const AttentionSignalRefSchema = CompanionAutonomySourceRefSchema;
+export const AttentionStructuredRefSchema = z.object({
+    ref: CompanionAutonomyRefSchema,
+    relation: z.enum([
+        "about",
+        "caused_by",
+        "blocks",
+        "depends_on",
+        "same_wait_condition",
+        "same_high_watermark",
+        "same_runtime_operation",
+        "same_policy",
+    ]).default("about"),
+    strength: z.number().min(0).max(1).default(1),
+}).strict();
+export const StalenessSnapshotSchema = z.object({
+    state: z.enum(["fresh", "aging", "stale", "needs_regrounding", "unknown"]),
+    observedAt: z.string().datetime(),
+    sourceHighWatermark: z.string().min(1).nullable().default(null),
+    reason: z.string().min(1),
+}).strict();
+export const SourceDiversitySummarySchema = z.object({
+    sourceKinds: z.array(z.string().min(1)).default([]),
+    independentSourceCount: z.number().int().nonnegative().default(0),
+    repeatedSourceCount: z.number().int().nonnegative().default(0),
+}).strict();
+export const AttentionEvidenceStrengthSchema = z.enum(["weak", "moderate", "strong", "unknown"]);
+export const AttentionThemeSchema = z.object({
+    label: z.string().min(1),
+    structuredRefs: z.array(AttentionStructuredRefSchema).default([]),
+    semanticFingerprint: z.string().min(1).nullable().default(null),
+    semanticProviderId: z.string().min(1).nullable().default(null),
+    semanticProviderVersion: z.string().min(1).nullable().default(null),
+    themeHints: z.array(z.string().min(1)).default([]),
+}).strict();
+export const SimilarityBasisSchema = z.object({
+    outcome: z.enum(["semantic", "structured_ref", "semantic_and_structured_ref", "manual_seed", "unknown"]),
+    confidence: z.number().min(0).max(1),
+    reasons: z.array(z.string().min(1)).default([]),
+}).strict();
+export const AttentionConflictSchema = z.object({
+    conflict_id: z.string().min(1),
+    kind: z.enum([
+        "scope_conflict",
+        "permission_conflict",
+        "sensitivity_conflict",
+        "semantic_conflict",
+        "freshness_conflict",
+        "policy_epoch_mismatch",
+        "correction_conflict",
+    ]),
+    reason: z.string().min(1),
+    refs: z.array(CompanionAutonomyRefSchema).default([]),
+    createdAt: z.string().datetime(),
+}).strict();
+export const AttentionSplitCandidateSchema = z.object({
+    split_id: z.string().min(1),
+    reason: z.string().min(1),
+    memberUrgeRefs: z.array(UrgeCandidateRefSchema).default([]),
+    confidence: z.number().min(0).max(1),
+    createdAt: z.string().datetime(),
+}).strict();
+export const AttentionMergeEventSchema = z.object({
+    event_id: z.string().min(1),
+    mergedAt: z.string().datetime(),
+    urgeRef: UrgeCandidateRefSchema,
+    previousClusterRef: AttentionClusterRefSchema.nullable().default(null),
+    basis: SimilarityBasisSchema,
+    reasons: z.array(z.string().min(1)).default([]),
+}).strict();
+export const AttentionSuppressionSchema = z.object({
+    reason: z.string().min(1),
+    suppressedAt: z.string().datetime(),
+    feedbackRef: CompanionAutonomyRefSchema.nullable().default(null),
+}).strict();
+export const AttentionClusterLifecycleSchema = z.enum([
+    "forming",
+    "watching",
+    "mature",
+    "split_pending",
+    "suppressed",
+    "forgotten",
+    "needs_regrounding",
+]);
+export const SignalSourceSchema = z.enum([
+    "runtime_event",
+    "goal",
+    "task",
+    "session",
+    "schedule_tick",
+    "wait_expiry",
+    "daemon",
+    "resident",
+    "observation",
+    "user_activity",
+    "drive",
+    "curiosity",
+    "dream_artifact",
+    "soil_retrieval",
+    "surface",
+    "memory",
+    "feedback",
+    "correction",
+    "automation",
+    "guardrail",
+    "backpressure",
+]);
+export const TimingContextSchema = z.object({
+    observed_at: z.string().datetime(),
+    local_time_zone: z.string().min(1).optional(),
+    quiet_hours_active: z.boolean().default(false),
+    cooldown_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    due_refs: z.array(CompanionAutonomyRefSchema).default([]),
+}).strict();
+export const SignalSafetyContextSchema = z.object({
+    safety_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    guardrail_refs: z.array(refWithKind("guardrail")).default([]),
+    backpressure_refs: z.array(refWithKind("backpressure")).default([]),
+    hard_blocked: z.boolean().default(false),
+    reason: z.string().min(1).optional(),
+}).strict();
+export const StaleTargetContextSchema = z.object({
+    stale_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    rejected_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    needs_regrounding_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    reason: z.string().min(1).optional(),
+}).strict();
+export const SignalContextSchema = z.object({
+    schema_version: z.literal("signal-context-v1").default("signal-context-v1"),
+    signal_context_id: z.string().min(1),
+    assembled_at: z.string().datetime(),
+    signal_sources: z.array(SignalSourceSchema).min(1),
+    signal_refs: z.array(CompanionAutonomySourceRefSchema).min(1),
+    active_surface_ref: refWithKind("surface").nullable(),
+    current_session_refs: z.array(refWithKind("session")).default([]),
+    current_goal_refs: z.array(refWithKind("goal")).default([]),
+    runtime_state_refs: z.array(refWithKind("runtime_item", "runtime_event")).default([]),
+    relationship_permission_refs: z.array(refWithKind("relationship_permission", "permission_grant")).default([]),
+    user_activity_refs: z.array(refWithKind("user_activity")).default([]),
+    timing_context: TimingContextSchema,
+    safety_context: SignalSafetyContextSchema,
+    stale_target_context: StaleTargetContextSchema,
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict();
+export const UrgeOriginSchema = z.enum([
+    "goal",
+    "memory",
+    "schedule",
+    "runtime_event",
+    "world_change",
+    "user_pattern",
+    "curiosity",
+    "drive",
+    "risk",
+    "guardrail",
+    "backpressure",
+    "correction",
+]);
+export const UrgeFeelingSchema = z.enum([
+    "curiosity",
+    "concern",
+    "care",
+    "opportunity",
+    "friction",
+    "completion_pressure",
+    "boundary_pressure",
+    "staleness_pressure",
+    "repair_pressure",
+]);
+export const AttentionMoveSchema = z.enum([
+    "notice",
+    "watch",
+    "hold",
+    "prepare",
+    "ask",
+    "speak",
+    "run_authorized_work",
+    "delegate_bounded_work",
+    "write_memory_candidate",
+    "update_surface_candidate",
+    "escalate",
+    "external_side_effect",
+]);
+export const AttentionMaturationStateSchema = z.enum([
+    "new",
+    "warming",
+    "mature",
+    "held",
+    "prepared",
+    "decayed",
+    "suppressed",
+    "expressed",
+    "expired",
+    "rejected_stale",
+]);
+export const AttentionDecayRuleSchema = z.object({
+    kind: z.enum(["fixed_deadline", "evidence_decay", "staleness_decay", "manual_recheck"]),
+    due_at: z.string().datetime().optional(),
+    reason: z.string().min(1),
+}).strict();
+export const AttentionMaturationSchema = z.object({
+    state: AttentionMaturationStateSchema,
+    first_seen_at: z.string().datetime(),
+    last_reinforced_at: z.string().datetime().optional(),
+    expires_at: z.string().datetime().optional(),
+    decay_rule: AttentionDecayRuleSchema.optional(),
+    reinforcement_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+    blocker_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+}).strict();
+export const AttentionMaturationTransitionCauseSchema = z.enum([
+    "repeated_evidence",
+    "goal_relevance",
+    "time_sensitivity",
+    "promise",
+    "safety_pressure",
+    "user_authorized_work",
+    "staleness_risk",
+    "low_confidence",
+    "high_interruption_cost",
+    "stale_target",
+    "sensitivity",
+    "missing_permission",
+    "dismissal",
+    "overload",
+    "boundary",
+    "anti_memory",
+    "expressed",
+    "expired",
+]);
+export const AttentionMaturationTransitionSchema = z.object({
+    schema_version: z.literal("attention-maturation-transition-v1").default("attention-maturation-transition-v1"),
+    transition_id: z.string().min(1),
+    candidate_ref: refWithKind("urge_candidate", "agent_agenda_item"),
+    from_state: AttentionMaturationStateSchema,
+    to_state: AttentionMaturationStateSchema,
+    cause: AttentionMaturationTransitionCauseSchema,
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).min(1),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict();
+export const UrgeCandidateSchema = z.object({
+    schema_version: z.literal("urge-candidate-v1").default("urge-candidate-v1"),
+    urge_id: z.string().min(1),
+    origin: UrgeOriginSchema,
+    target: CompanionAutonomyRefSchema,
+    feeling: UrgeFeelingSchema,
+    subject: z.string().min(1),
+    strength: z.number().min(0).max(1),
+    confidence: z.number().min(0).max(1),
+    urgency: AttentionPrioritySchema,
+    expected_user_benefit: z.string().min(1),
+    user_cost: AttentionRiskAssessmentSchema,
+    relationship_risk: AttentionRiskAssessmentSchema,
+    side_effect_risk: AttentionRiskAssessmentSchema,
+    sensitivity: AttentionSensitivitySchema,
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).min(1),
+    surface_ref: refWithKind("surface").nullable().default(null),
+    companion_state_ref: refWithKind("companion_state").nullable().default(null),
+    allowed_moves: z.array(AttentionMoveSchema).default([]),
+    forbidden_moves: z.array(AttentionMoveSchema).default([]),
+    maturation: AttentionMaturationSchema,
+    scope: AttentionScopeSchema.default(DEFAULT_ATTENTION_SCOPE),
+    signalRefs: z.array(AttentionSignalRefSchema).default([]),
+    structuredRefs: z.array(AttentionStructuredRefSchema).default([]),
+    semanticFingerprint: z.string().min(1).nullable().default(null),
+    semanticProviderId: z.string().min(1).nullable().default(null),
+    semanticProviderVersion: z.string().min(1).nullable().default(null),
+    sourceDiversity: SourceDiversitySummarySchema.default({
+        sourceKinds: [],
+        independentSourceCount: 0,
+        repeatedSourceCount: 0,
+    }),
+    stalenessSnapshot: StalenessSnapshotSchema.default({
+        state: "needs_regrounding",
+        observedAt: "1970-01-01T00:00:00.000Z",
+        sourceHighWatermark: null,
+        reason: "legacy urge candidate requires regrounding before outward admission",
+    }),
+    evidenceStrength: AttentionEvidenceStrengthSchema.default("unknown"),
+    uncertainty: z.number().min(0).max(1).default(1),
+    conflictMarkers: z.array(AttentionConflictSchema).default([]),
+    policyEpoch: z.string().min(1).default("unknown"),
+    modelOrClassifierVersion: z.string().min(1).nullable().default(null),
+    replayableInputRefs: z.array(CompanionAutonomyRefSchema).default([]),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict().superRefine((urge, ctx) => {
+    const overlap = urge.allowed_moves.filter((move) => urge.forbidden_moves.includes(move));
+    if (overlap.length > 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["allowed_moves"],
+            message: `attention moves cannot be both allowed and forbidden: ${overlap.join(", ")}`,
+        });
+    }
+});
+export const AttentionClusterSchema = z.object({
+    id: z.string().min(1),
+    scope: AttentionScopeSchema,
+    theme: AttentionThemeSchema,
+    memberUrgeRefs: z.array(UrgeCandidateRefSchema).default([]),
+    signalRefs: z.array(AttentionSignalRefSchema).default([]),
+    similarityBasis: SimilarityBasisSchema,
+    aggregateStrength: z.number().min(0).max(1),
+    aggregateConfidence: z.number().min(0).max(1),
+    uncertainty: z.number().min(0).max(1),
+    sourceDiversity: SourceDiversitySummarySchema,
+    maturation: AttentionMaturationSchema,
+    lifecycle: AttentionClusterLifecycleSchema,
+    conflicts: z.array(AttentionConflictSchema).default([]),
+    splitCandidates: z.array(AttentionSplitCandidateSchema).default([]),
+    mergeHistory: z.array(AttentionMergeEventSchema).default([]),
+    suppression: AttentionSuppressionSchema.optional(),
+    forgetAfter: z.string().datetime().nullable().default(null),
+    lastRegroundedAt: z.string().datetime().nullable().default(null),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+}).strict();
+export const AgentAgendaItemKindSchema = z.enum([
+    "goal_stewardship",
+    "project_drift",
+    "commitment_guard",
+    "memory_conflict",
+    "preparation_opportunity",
+    "stall_concern",
+    "decay_risk",
+    "curiosity_followup",
+    "unresolved_decision",
+    "permission_boundary",
+    "surface_staleness",
+    "user_overload",
+    "self_maintenance",
+]);
+export const AgendaPostureSchema = z.enum([
+    "new",
+    "warming",
+    "held",
+    "prepared",
+    "ready_for_gate",
+    "admitted",
+    "suppressed",
+    "expired",
+    "rejected_stale",
+]);
+export const AgentCarePostureSchema = z.enum([
+    "notice",
+    "watch",
+    "hold",
+    "prepare",
+    "ask",
+    "offer",
+    "act_candidate",
+    "silence",
+]);
+export const AttentionCommitmentLifecycleSchema = z.enum([
+    "uncommitted",
+    "watching",
+    "held",
+    "proposed",
+    "admitted",
+    "terminal",
+]);
+export const AgendaControlStateSchema = z.enum([
+    "active",
+    "held",
+    "paused",
+    "stopped",
+    "suppressed",
+    "expired",
+]);
+export const AttentionRevisitConditionSchema = z.object({
+    kind: z.enum([
+        "none",
+        "time",
+        "user_activity",
+        "surface_refresh",
+        "permission_change",
+        "staleness_change",
+        "runtime_event",
+        "cooldown_elapsed",
+        "manual_review",
+    ]),
+    due_at: z.string().datetime().optional(),
+    refs: z.array(CompanionAutonomyRefSchema).default([]),
+    reason: z.string().min(1).optional(),
+}).strict().superRefine((condition, ctx) => {
+    if (condition.kind === "time" && !condition.due_at) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["due_at"],
+            message: "time revisit conditions require due_at",
+        });
+    }
+});
+export const AgendaMergeTraceSchema = z.object({
+    dedupe_key: z.string().min(1),
+    basis: z.object({
+        target: z.boolean(),
+        evidence: z.boolean(),
+        surface: z.boolean(),
+        kind: z.boolean(),
+        current_posture: z.boolean(),
+    }).strict(),
+    merged_urge_refs: z.array(UrgeCandidateRefSchema).default([]),
+    reinforced_by_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict();
+export const AgentAgendaItemSchema = z.object({
+    schema_version: z.literal("agent-agenda-item-v1").default("agent-agenda-item-v1"),
+    agenda_item_id: z.string().min(1),
+    origin: UrgeOriginSchema,
+    kind: AgentAgendaItemKindSchema,
+    subject: z.string().min(1),
+    why_pulseed_cares: z.string().min(1),
+    expected_user_benefit: z.string().min(1),
+    related_goal_refs: z.array(refWithKind("goal")).default([]),
+    related_memory_refs: z.array(refWithKind("memory")).default([]),
+    related_surface_refs: z.array(refWithKind("surface")).default([]),
+    related_runtime_refs: z.array(refWithKind("runtime_item", "runtime_event")).default([]),
+    source_urge_refs: z.array(UrgeCandidateRefSchema).default([]),
+    drive_basis: z.string().min(1).optional(),
+    curiosity_basis: z.string().min(1).optional(),
+    confidence: z.number().min(0).max(1),
+    intrusion_cost: AttentionRiskAssessmentSchema,
+    relationship_risk: AttentionRiskAssessmentSchema,
+    staleness_state: z.enum(["current", "needs_review", "needs_regrounding", "stale", "rejected"]),
+    allowed_moves: z.array(AttentionMoveSchema).default([]),
+    forbidden_moves: z.array(AttentionMoveSchema).default([]),
+    current_posture: AgendaPostureSchema,
+    maturation: AttentionMaturationSchema,
+    revisit_condition: AttentionRevisitConditionSchema,
+    control_state: AgendaControlStateSchema,
+    merge_trace: AgendaMergeTraceSchema.optional(),
+    clusterRef: AttentionClusterRefSchema.nullable().default(null),
+    carePosture: AgentCarePostureSchema.default("watch"),
+    revisitCondition: AttentionRevisitConditionSchema.optional(),
+    abandonmentCondition: AttentionRevisitConditionSchema.optional(),
+    suppressionReason: z.string().min(1).nullable().default(null),
+    commitmentLifecycle: AttentionCommitmentLifecycleSchema.default("held"),
+    needsRegrounding: z.boolean().default(true),
+    scope: AttentionScopeSchema.default(DEFAULT_ATTENTION_SCOPE),
+    policyEpoch: z.string().min(1).default("unknown"),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict().superRefine((item, ctx) => {
+    const overlap = item.allowed_moves.filter((move) => item.forbidden_moves.includes(move));
+    if (overlap.length > 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["allowed_moves"],
+            message: `agenda moves cannot be both allowed and forbidden: ${overlap.join(", ")}`,
+        });
+    }
+});
+export const AgendaDecompositionChildSchema = z.object({
+    id: z.string().min(1),
+    parentAgendaRef: AgentAgendaRefSchema,
+    clusterRef: AttentionClusterRefSchema,
+    childType: z.enum(["watch", "prepare", "ask", "digest", "action_candidate", "silence"]),
+    idempotencyKey: z.string().min(1),
+    requiredAuthority: z.enum(["none", "read", "draft", "notify", "write"]),
+    permissionScope: AttentionPermissionScopeSchema,
+    stalenessSnapshot: StalenessSnapshotSchema,
+    candidatePayloadRef: z.string().min(1).nullable().default(null),
+    admissionState: z.enum(["not_admitted", "admitted", "rejected", "expired", "needs_approval"]),
+    outcomeRef: z.string().min(1).nullable().default(null),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+}).strict();
+export const AgendaDecompositionSchema = z.object({
+    id: z.string().min(1),
+    agendaRef: AgentAgendaRefSchema,
+    clusterRef: AttentionClusterRefSchema,
+    scope: AttentionScopeSchema,
+    children: z.array(AgendaDecompositionChildSchema).default([]),
+    status: z.enum(["open", "partially_admitted", "closed", "suppressed", "needs_regrounding"]),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+}).strict();
+export const InhibitionDecisionKindSchema = z.enum([
+    "suppress",
+    "hold",
+    "watch",
+    "wait_for_opportunity",
+    "decay",
+    "reject_stale",
+    "allow_to_gate",
+]);
+export const CompanionStateEffectSchema = z.enum([
+    "none",
+    "raise_thresholds",
+    "lower_thresholds",
+    "hold_back",
+    "cooldown",
+    "needs_user",
+    "overloaded",
+]);
+const MaturationStatesByInhibitionDecision = {
+    suppress: ["suppressed"],
+    hold: ["held"],
+    watch: ["held", "warming"],
+    wait_for_opportunity: ["held", "warming"],
+    decay: ["decayed"],
+    reject_stale: ["rejected_stale"],
+    allow_to_gate: ["mature", "prepared"],
+};
+export const OutcomeClassSchema = z.enum([
+    "silence",
+    "keep_watching",
+    "hold_in_agenda",
+    "prepare_silently",
+    "run_authorized_work",
+    "delegate_bounded_work",
+    "prepare_action_candidate",
+    "request_approval",
+    "write_governed_memory_candidate",
+    "update_surface_candidate",
+    "add_to_digest",
+    "express_to_user",
+    "escalate",
+]);
+export const SurfaceFacingOutcomeClassSchema = z.enum([
+    "add_to_digest",
+    "express_to_user",
+    "request_approval",
+    "escalate",
+]);
+export const InhibitionDecisionSchema = z.object({
+    schema_version: z.literal("inhibition-decision-v1").default("inhibition-decision-v1"),
+    decision_id: z.string().min(1),
+    target_ref: refWithKind("urge_candidate", "agent_agenda_item"),
+    decided_at: z.string().datetime(),
+    decision: InhibitionDecisionKindSchema,
+    reason: z.string().min(1),
+    companion_state_effect: CompanionStateEffectSchema,
+    updated_maturation_state: AttentionMaturationStateSchema,
+    revisit_condition: AttentionRevisitConditionSchema,
+    suppressed_alternatives: z.array(OutcomeClassSchema).default([]),
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).min(1),
+    policy_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict().superRefine((decision, ctx) => {
+    const allowedStates = MaturationStatesByInhibitionDecision[decision.decision];
+    if (!allowedStates.includes(decision.updated_maturation_state)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["updated_maturation_state"],
+            message: `${decision.decision} cannot update maturation to ${decision.updated_maturation_state}`,
+        });
+    }
+});
+export const AutonomyCheckStatusSchema = z.enum(["passed", "failed", "unknown", "not_required"]);
+export const AutonomyCheckKindSchema = z.enum([
+    "scope",
+    "lifecycle",
+    "permission",
+    "staleness",
+    "sensitivity",
+    "surface",
+    "allowed_use",
+    "forbidden_use",
+    "projection",
+    "audit",
+    "authority",
+    "safety",
+    "guardrail",
+    "runtime_control",
+    "companion_state",
+    "companion_control",
+    "backpressure",
+    "capacity",
+    "cooldown",
+    "visibility",
+]);
+export const AutonomyCheckSchema = z.object({
+    check_id: z.string().min(1),
+    kind: AutonomyCheckKindSchema,
+    status: AutonomyCheckStatusSchema,
+    reason: z.string().min(1),
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+}).strict();
+export const InitiativeGateDecisionSchema = z.object({
+    schema_version: z.literal("initiative-gate-decision-v1").default("initiative-gate-decision-v1"),
+    decision_id: z.string().min(1),
+    decided_at: z.string().datetime(),
+    status: z.enum(["selected", "blocked", "delayed", "narrowed"]),
+    input_refs: z.array(refWithKind("urge_candidate", "agent_agenda_item", "inhibition_decision")).min(1),
+    selected_outcome: OutcomeClassSchema.optional(),
+    reason: z.string().min(1),
+    why_this: z.string().min(1).optional(),
+    why_now: z.string().min(1).optional(),
+    why_this_route: z.string().min(1).optional(),
+    permission_checks: z.array(AutonomyCheckSchema).default([]),
+    staleness_checks: z.array(AutonomyCheckSchema).default([]),
+    sensitivity_checks: z.array(AutonomyCheckSchema).default([]),
+    side_effect_checks: z.array(AutonomyCheckSchema).default([]),
+    alternatives_considered: z.array(OutcomeClassSchema).default([]),
+    suppressed_alternatives: z.array(OutcomeClassSchema).default([]),
+    required_runtime_control_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    required_approval: z.boolean().default(false),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict().superRefine((decision, ctx) => {
+    if (decision.status === "selected" && !decision.selected_outcome) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["selected_outcome"],
+            message: "selected initiative gate decisions require selected_outcome",
+        });
+    }
+    if (decision.status !== "selected" && decision.selected_outcome) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["selected_outcome"],
+            message: "blocked, delayed, and narrowed gate decisions must not create an outcome",
+        });
+    }
+});
+export const OutcomeAdmissionStatusSchema = z.enum([
+    "admitted",
+    "rejected",
+    "downgraded",
+    "expired",
+    "held",
+]);
+export const OutcomeDecisionReasonCodeSchema = z.enum([
+    "stale_target",
+    "missing_permission",
+    "invalid_surface",
+    "guardrail_blocked",
+    "backpressure",
+    "approval_required",
+    "overloaded",
+    "cooling_down",
+    "control_suppressed",
+    "authority_unknown",
+    "expired",
+    "safety_blocked",
+]);
+export const OutcomeDecisionReasonSchema = z.object({
+    code: OutcomeDecisionReasonCodeSchema,
+    detail: z.string().min(1),
+    evidence_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+}).strict();
+export const OutcomeDecisionSchema = z.object({
+    schema_version: z.literal("outcome-decision-v1").default("outcome-decision-v1"),
+    outcome_decision_id: z.string().min(1),
+    initiative_decision_ref: InitiativeGateDecisionRefSchema,
+    decided_at: z.string().datetime(),
+    requested_outcome: OutcomeClassSchema,
+    admission_status: OutcomeAdmissionStatusSchema,
+    final_outcome: OutcomeClassSchema.optional(),
+    runtime_item_refs: z.array(refWithKind("runtime_item")).default([]),
+    authority_checks: z.array(AutonomyCheckSchema).default([]),
+    staleness_checks: z.array(AutonomyCheckSchema).default([]),
+    companion_control_checks: z.array(AutonomyCheckSchema).default([]),
+    safety_checks: z.array(AutonomyCheckSchema).default([]),
+    visibility_checks: z.array(AutonomyCheckSchema).default([]),
+    downgrade_or_rejection_reason: OutcomeDecisionReasonSchema.optional(),
+    visibility_policy_ref: VisibilityPolicyRefSchema.optional(),
+    expression_decision_ref: refWithKind("expression_decision").optional(),
+    audit_ref: AuditTraceRefSchema.optional(),
+}).strict().superRefine((decision, ctx) => {
+    if ((decision.admission_status === "admitted" || decision.admission_status === "downgraded") &&
+        !decision.final_outcome) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["final_outcome"],
+            message: "admitted and downgraded outcome decisions require a final outcome class",
+        });
+    }
+    if ((decision.admission_status === "rejected" ||
+        decision.admission_status === "expired" ||
+        decision.admission_status === "held") &&
+        decision.final_outcome) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["final_outcome"],
+            message: "rejected, expired, and held outcome decisions must not invent a final outcome",
+        });
+    }
+    if ((decision.admission_status === "rejected" ||
+        decision.admission_status === "expired" ||
+        decision.admission_status === "held") &&
+        decision.expression_decision_ref) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expression_decision_ref"],
+            message: "rejected, expired, and held outcome decisions must not reference expression decisions",
+        });
+    }
+    if ((decision.admission_status === "rejected" ||
+        decision.admission_status === "downgraded" ||
+        decision.admission_status === "expired") &&
+        !decision.downgrade_or_rejection_reason) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["downgrade_or_rejection_reason"],
+            message: "rejected, downgraded, and expired outcomes require recorded reason evidence",
+        });
+    }
+    if (decision.expression_decision_ref && decision.final_outcome) {
+        const expressionAllowed = SurfaceFacingOutcomeClassSchema.safeParse(decision.final_outcome).success;
+        if (!expressionAllowed) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["expression_decision_ref"],
+                message: "only surface-facing final outcomes can reference an expression decision",
+            });
+        }
+    }
+});
+export const ExpressionDecisionStatusSchema = z.enum(["active", "held", "withdrawn"]);
+export const ExpressionModeSchema = z.enum([
+    "ambient_presence",
+    "digest_item",
+    "soft_ping",
+    "direct_message",
+    "approval_request",
+    "urgent_alert",
+    "intervention",
+]);
+export const ExpressionSurfaceClassSchema = z.enum([
+    "chat",
+    "tui",
+    "cli",
+    "digest",
+    "daemon_snapshot",
+    "gui",
+    "gateway",
+    "notification",
+]);
+export const ExpressionDecisionSchema = z.object({
+    schema_version: z.literal("expression-decision-v1").default("expression-decision-v1"),
+    expression_decision_id: z.string().min(1),
+    outcome_decision_ref: OutcomeDecisionRefSchema,
+    outcome_class: SurfaceFacingOutcomeClassSchema,
+    created_at: z.string().datetime(),
+    expression_mode: ExpressionModeSchema,
+    target_surface_classes: z.array(ExpressionSurfaceClassSchema).min(1),
+    visibility_policy_ref: VisibilityPolicyRefSchema,
+    decision_status: ExpressionDecisionStatusSchema.default("active"),
+    user_facing_rationale: z.string().min(1),
+    suppressed_detail_refs: z.array(CompanionAutonomyRefSchema).default([]),
+    audit_ref: AuditTraceRefSchema.optional(),
+}).strict().superRefine((decision, ctx) => {
+    if (decision.outcome_class === "add_to_digest" && decision.expression_mode !== "digest_item") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expression_mode"],
+            message: "add_to_digest outcomes must render through digest_item expression mode",
+        });
+    }
+    if (decision.outcome_class === "request_approval" && decision.expression_mode !== "approval_request") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expression_mode"],
+            message: "request_approval outcomes must render through approval_request expression mode",
+        });
+    }
+    if (decision.outcome_class === "escalate" &&
+        decision.expression_mode !== "urgent_alert" &&
+        decision.expression_mode !== "intervention") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expression_mode"],
+            message: "escalate outcomes require urgent_alert or intervention expression mode",
+        });
+    }
+});
+export const VisibilityPolicySchema = z.object({
+    schema_version: z.literal("visibility-policy-v1").default("visibility-policy-v1"),
+    visibility_policy_id: z.string().min(1),
+    applies_to: z.array(CompanionAutonomyRefSchema).min(1),
+    hidden_by_default: z.boolean(),
+    visible_in_gui: z.boolean(),
+    visible_in_chat: z.boolean(),
+    visible_in_tui: z.boolean(),
+    visible_in_cli: z.boolean(),
+    visible_in_audit: z.boolean(),
+    visible_in_debug: z.boolean(),
+    digest_only: z.boolean(),
+    visible_in_digest: z.boolean().default(false),
+    never_directly_show: z.boolean(),
+    content_lifecycle: CompanionAutonomyContentLifecycleSchema.default("active"),
+    redaction_required: z.boolean().default(false),
+    raw_content_allowed: z.boolean().default(false),
+    inspectable_summary: z.string().min(1).optional(),
+    rationale: z.string().min(1),
+    audit_refs: z.array(AuditTraceRefSchema).default([]),
+}).strict().superRefine((policy, ctx) => {
+    if ((policy.content_lifecycle === "deleted" || policy.content_lifecycle === "tombstone") &&
+        policy.raw_content_allowed) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["raw_content_allowed"],
+            message: "deleted and tombstone content cannot be exposed through visibility policy",
+        });
+    }
+    if ((policy.content_lifecycle === "deleted" || policy.content_lifecycle === "tombstone") &&
+        !policy.redaction_required) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["redaction_required"],
+            message: "deleted and tombstone content require redaction",
+        });
+    }
+    if (policy.never_directly_show &&
+        (policy.visible_in_gui ||
+            policy.visible_in_chat ||
+            policy.visible_in_tui ||
+            policy.visible_in_cli ||
+            policy.visible_in_digest)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["never_directly_show"],
+            message: "never_directly_show content cannot be visible in normal surfaces or digest",
+        });
+    }
+    if (policy.digest_only &&
+        (policy.visible_in_chat || policy.visible_in_tui || policy.visible_in_cli || !policy.visible_in_digest)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["digest_only"],
+            message: "digest_only content must be digest-visible and hidden from immediate chat, TUI, and CLI surfaces",
+        });
+    }
+});
+export const AuditRepairOptionSchema = z.enum([
+    "stop",
+    "narrow",
+    "revoke",
+    "forget",
+    "reground",
+    "suppress",
+    "inspect",
+    "retry",
+]);
+export const AuditTraceRecordSchema = z.object({
+    record_id: z.string().min(1),
+    summary: z.string().min(1),
+    source_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+    redacted: z.boolean().default(false),
+}).strict();
+export const AuditRedactionStateSchema = z.object({
+    state: z.enum(["none", "redacted", "tombstone_metadata", "deleted_source_removed"]),
+    redaction_applied: z.boolean().default(false),
+    deleted_content_visible: z.boolean().default(false),
+    reason: z.string().min(1).optional(),
+}).strict();
+export const AuditTraceSchema = z.object({
+    schema_version: z.literal("audit-trace-v1").default("audit-trace-v1"),
+    trace_id: z.string().min(1),
+    subject_ref: CompanionAutonomyRefSchema,
+    trigger_refs: z.array(CompanionAutonomySourceRefSchema).min(1),
+    surface_refs: z.array(refWithKind("surface")).default([]),
+    memory_refs: z.array(CompanionAutonomySourceRefSchema).default([]),
+    permission_checks: z.array(AutonomyCheckSchema).default([]),
+    staleness_checks: z.array(AutonomyCheckSchema).default([]),
+    authority_checks: z.array(AutonomyCheckSchema).default([]),
+    safety_checks: z.array(AutonomyCheckSchema).default([]),
+    redaction_state: AuditRedactionStateSchema,
+    attention_decision_refs: z.array(refWithKind("inhibition_decision", "initiative_gate_decision", "outcome_decision", "expression_decision")).default([]),
+    companion_state_refs: z.array(refWithKind("companion_state")).default([]),
+    actions_taken: z.array(AuditTraceRecordSchema).default([]),
+    actions_withheld: z.array(AuditTraceRecordSchema).default([]),
+    quiet_work: z.array(AuditTraceRecordSchema).default([]),
+    suppressed_alternatives: z.array(AuditTraceRecordSchema).default([]),
+    user_visible_outputs: z.array(AuditTraceRecordSchema).default([]),
+    repair_options: z.array(AuditRepairOptionSchema).default([]),
+    visibility_policy_refs: z.array(VisibilityPolicyRefSchema).default([]),
+    created_at: z.string().datetime(),
+}).strict().superRefine((trace, ctx) => {
+    const allContentRefs = [
+        ...trace.trigger_refs,
+        ...trace.memory_refs,
+        ...trace.actions_taken.flatMap((record) => record.source_refs),
+        ...trace.actions_withheld.flatMap((record) => record.source_refs),
+        ...trace.quiet_work.flatMap((record) => record.source_refs),
+        ...trace.suppressed_alternatives.flatMap((record) => record.source_refs),
+        ...trace.user_visible_outputs.flatMap((record) => record.source_refs),
+        ...trace.permission_checks.flatMap((check) => check.evidence_refs),
+        ...trace.staleness_checks.flatMap((check) => check.evidence_refs),
+        ...trace.authority_checks.flatMap((check) => check.evidence_refs),
+        ...trace.safety_checks.flatMap((check) => check.evidence_refs),
+    ];
+    const hasDeletedOrTombstoneContent = allContentRefs.some((ref) => ref.lifecycle === "deleted" || ref.lifecycle === "tombstone");
+    if (hasDeletedOrTombstoneContent && !trace.redaction_state.redaction_applied) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["redaction_state", "redaction_applied"],
+            message: "audit traces referencing deleted or tombstone content require redaction",
+        });
+    }
+    if (hasDeletedOrTombstoneContent && trace.redaction_state.state === "none") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["redaction_state", "state"],
+            message: "audit traces referencing deleted or tombstone content cannot use redaction state none",
+        });
+    }
+    if (trace.redaction_state.deleted_content_visible) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["redaction_state", "deleted_content_visible"],
+            message: "audit traces must not expose deleted content",
+        });
+    }
+    for (const [recordPath, records] of [
+        ["actions_taken", trace.actions_taken],
+        ["actions_withheld", trace.actions_withheld],
+        ["quiet_work", trace.quiet_work],
+        ["suppressed_alternatives", trace.suppressed_alternatives],
+        ["user_visible_outputs", trace.user_visible_outputs],
+    ]) {
+        records.forEach((record, recordIndex) => {
+            const recordUsesDeletedContent = record.source_refs.some((ref) => ref.lifecycle === "deleted" || ref.lifecycle === "tombstone");
+            if (recordUsesDeletedContent && !record.redacted) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [recordPath, recordIndex, "redacted"],
+                    message: "audit trace records that reference deleted or tombstone content must be redacted",
+                });
+            }
+        });
+    }
+});
+export const PermissionGrantBoundarySchema = z.object({
+    schema_version: z.literal("permission-grant-boundary-v1").default("permission-grant-boundary-v1"),
+    grant_id: z.string().min(1),
+    state: z.enum(["proposed", "active", "expired", "revoked", "superseded"]),
+    capabilities: z.array(PermissionGrantCapabilitySchema).min(1),
+    excluded_capabilities: z.array(PermissionGrantExcludedCapabilitySchema).min(1),
+    visibility_policy_ref: CompanionAutonomyRefSchema.optional(),
+    audit_refs: z.array(z.string().min(1)).default([]),
+}).strict();
+export function canVisibilityPolicyExposeRawContent(policy) {
+    if (policy.content_lifecycle === "deleted" || policy.content_lifecycle === "tombstone")
+        return false;
+    if (policy.never_directly_show)
+        return false;
+    if (policy.redaction_required)
+        return false;
+    return policy.raw_content_allowed;
+}
+//# sourceMappingURL=companion-autonomy.js.map