@oscharko-dev/keiko-contracts 0.2.8 → 0.2.9

package/dist/discussion-intelligence.js

@@ -0,0 +1,440 @@
+// Discussion Intelligence contract for colleague-like discussion behavior (Epic #491, Issue #502,
+// ADR-0065). This leaf module DEFINES the provider-neutral, text-first semantics that let Keiko run the
+// five discussion modes (Challenge / Review / Decide / Brainstorm / Evidence-check), disagree
+// professionally grounded in evidence + assumptions + uncertainty, surface confidence, and recover an
+// interrupted spoken discussion turn without losing the active question or decision context.
+//
+// It is pure data + pure functions only — nothing performs IO, crypto, clock reads, randomness, or audio
+// processing. No raw user / assistant text, transcript excerpt, credential, provider URL, or tool grant
+// is ever a field on these types: every value that crosses a boundary is a closed enum, a bool, a bounded
+// 0–1 float, an int, or a fixed content-free template string (the server renders these templates verbatim
+// as an ADDITIVE block; `CONVERSATION_SYSTEM_PROMPT` stays immutable).
+//
+// Reuse, not a parallel stack (Issue #502 AC2): the citation / contradiction / grounding vocabulary is
+// imported from `./prompt-enhancer.js`, and voice gating is derived from `./voice-transcript.js`'s
+// `voiceTranscriptCaptureAllowed` rather than re-encoding the voice profile table. Discussion
+// intelligence ITSELF is always available (text-first, AC1); the voice predicate only governs whether
+// SPOKEN turns may drive it.
+//
+// `DISCUSSION_INTELLIGENCE_SCHEMA_VERSION` follows the same evolution rule as the sibling schema
+// versions (ADR-0010 D2): a breaking change introduces a NEW literal rather than mutating "1", and it is
+// INDEPENDENT of every other schema version. Leaf-package rule (ADR-0019 direction 1): no
+// `@oscharko-dev/keiko-*` import may appear here; siblings are reached by relative path.
+import { voiceTranscriptCaptureAllowed } from "./voice-transcript.js";
+// ─── Schema version ───────────────────────────────────────────────────────────
+export const DISCUSSION_INTELLIGENCE_SCHEMA_VERSION = "1";
+export function isDiscussionIntelligenceSchemaVersionSupported(version) {
+    return version === DISCUSSION_INTELLIGENCE_SCHEMA_VERSION;
+}
+export const DISCUSSION_MODES = [
+    "challenge",
+    "review",
+    "decide",
+    "brainstorm",
+    "evidence-check",
+];
+export function isDiscussionMode(value) {
+    return typeof value === "string" && DISCUSSION_MODES.includes(value);
+}
+export function assertNeverDiscussionMode(value) {
+    throw new TypeError(`Unhandled DiscussionMode: ${JSON.stringify(value)}`);
+}
+export const DISCUSSION_CONFIDENCE_LEVELS = [
+    "high",
+    "medium",
+    "low",
+];
+// Cut points (documented + tested): a non-finite or out-of-[0,1] score is guarded to `low` (the most
+// cautious level — never overstate confidence). Within range: `< 1/3 → low`, `< 2/3 → medium`, else
+// `high`. The boundaries 1/3 and 2/3 themselves round UP (1/3 is medium, 2/3 is high), matching the
+// segment-fill thresholds.
+const CONFIDENCE_LOW_CEILING = 1 / 3;
+const CONFIDENCE_MEDIUM_CEILING = 2 / 3;
+export function confidenceLevelFromScore(score) {
+    if (!Number.isFinite(score) || score < 0 || score > 1) {
+        return "low";
+    }
+    if (score < CONFIDENCE_LOW_CEILING) {
+        return "low";
+    }
+    if (score < CONFIDENCE_MEDIUM_CEILING) {
+        return "medium";
+    }
+    return "high";
+}
+export const DISAGREEMENT_FACETS = [
+    "evidence",
+    "assumptions",
+    "uncertainty",
+];
+export const DISCUSSION_DIRECTIVES = [
+    "state-position-then-evidence",
+    "challenge-stated-assumptions",
+    "surface-counter-evidence",
+    "list-explicit-assumptions",
+    "disclose-uncertainty-and-confidence",
+    "cite-evidence-or-state-none",
+    "offer-decision-with-tradeoffs",
+    "expand-option-space-before-converging",
+    "verify-claims-against-evidence",
+    "defer-to-user-on-unresolved-contradiction",
+];
+export function assertNeverDiscussionDirective(value) {
+    throw new TypeError(`Unhandled DiscussionDirective: ${JSON.stringify(value)}`);
+}
+// Fixed, content-free instruction templates. Bounded length; no raw input echo, no credential, provider
+// URL, system prompt, or tool/secret/egress authority encodable here. Keyed by directive for totality.
+export const DISCUSSION_DIRECTIVE_TEMPLATES = {
+    "state-position-then-evidence": "State your position first, then the evidence that supports it.",
+    "challenge-stated-assumptions": "Identify and challenge the assumptions the stated position depends on.",
+    "surface-counter-evidence": "Surface evidence that weighs against the position, not only evidence for it.",
+    "list-explicit-assumptions": "List the explicit assumptions you are making before drawing a conclusion.",
+    "disclose-uncertainty-and-confidence": "Disclose your remaining uncertainty and your confidence level for each claim.",
+    "cite-evidence-or-state-none": "Cite the evidence for each claim, or state plainly that no evidence is available.",
+    "offer-decision-with-tradeoffs": "Offer a recommended next action and lay out the trade-offs of each option.",
+    "expand-option-space-before-converging": "Expand the range of options before converging on a single recommendation.",
+    "verify-claims-against-evidence": "Verify each claim against the available evidence before accepting it.",
+    "defer-to-user-on-unresolved-contradiction": "When a contradiction cannot be resolved from evidence, defer the decision to the user.",
+};
+// Maps each directive to the disagreement facet(s) its template addresses (AC3). Keyed by directive for
+// totality (a new directive without an entry is a compile error). A directive whose template is about
+// the decision shape or deferral rather than a disagreement facet maps to the empty array. This is the
+// machine-checkable bridge between a mode's rendered directives and the facets it mandates: the regression
+// guard `discussionDirectivesCoverFacets` proves every mode's directives actually instruct the model on
+// the facets the mode mandates (so e.g. an `evidence`-mandating mode cannot silently drop evidence from
+// its rendered prompt).
+export const DISCUSSION_DIRECTIVE_FACETS = {
+    "state-position-then-evidence": ["evidence"],
+    "challenge-stated-assumptions": ["assumptions"],
+    "surface-counter-evidence": ["evidence"],
+    "list-explicit-assumptions": ["assumptions"],
+    "disclose-uncertainty-and-confidence": ["uncertainty"],
+    "cite-evidence-or-state-none": ["evidence"],
+    "offer-decision-with-tradeoffs": [],
+    "expand-option-space-before-converging": [],
+    "verify-claims-against-evidence": ["evidence"],
+    "defer-to-user-on-unresolved-contradiction": [],
+};
+// Frozen TOTAL table keyed by mode (a new mode without a plan is a compile error). Invariant enforced in
+// tests: every disagreement-capable mode (challenge/review/decide/evidence-check) mandates ALL THREE
+// `DISAGREEMENT_FACETS`; `brainstorm` relaxes uncertainty (it expands options rather than disagreeing).
+export const DISCUSSION_MODE_PLANS = {
+    challenge: {
+        mode: "challenge",
+        challengesAssumptions: true,
+        requiresExplicitAssumptions: true,
+        requiresUncertaintyDisclosure: true,
+        citationDiscipline: "require-citations-or-state-no-evidence",
+        contradictionPolicy: "disclose-and-defer",
+        groundingDirectives: [
+            "stay-within-evidence",
+            "disclose-uncertainty",
+            "separate-known-from-retrieved",
+        ],
+        producesDecisionRecommendation: false,
+        mandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        directives: [
+            "state-position-then-evidence",
+            "challenge-stated-assumptions",
+            "surface-counter-evidence",
+            "list-explicit-assumptions",
+            "disclose-uncertainty-and-confidence",
+        ],
+    },
+    review: {
+        mode: "review",
+        challengesAssumptions: true,
+        requiresExplicitAssumptions: true,
+        requiresUncertaintyDisclosure: true,
+        citationDiscipline: "require-citations-or-state-no-evidence",
+        contradictionPolicy: "disclose-and-defer",
+        groundingDirectives: [
+            "attribute-claims-to-sources",
+            "stay-within-evidence",
+            "disclose-uncertainty",
+        ],
+        producesDecisionRecommendation: false,
+        mandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        directives: [
+            "verify-claims-against-evidence",
+            "surface-counter-evidence",
+            "list-explicit-assumptions",
+            "disclose-uncertainty-and-confidence",
+        ],
+    },
+    decide: {
+        mode: "decide",
+        challengesAssumptions: true,
+        requiresExplicitAssumptions: true,
+        requiresUncertaintyDisclosure: true,
+        citationDiscipline: "require-citations-or-state-no-evidence",
+        contradictionPolicy: "disclose-and-defer",
+        groundingDirectives: ["stay-within-evidence", "disclose-uncertainty"],
+        producesDecisionRecommendation: true,
+        mandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        directives: [
+            "cite-evidence-or-state-none",
+            "list-explicit-assumptions",
+            "offer-decision-with-tradeoffs",
+            "disclose-uncertainty-and-confidence",
+            "defer-to-user-on-unresolved-contradiction",
+        ],
+    },
+    brainstorm: {
+        mode: "brainstorm",
+        challengesAssumptions: false,
+        requiresExplicitAssumptions: true,
+        requiresUncertaintyDisclosure: false,
+        citationDiscipline: "best-effort",
+        contradictionPolicy: "synthesize-with-caveats",
+        groundingDirectives: ["separate-known-from-retrieved"],
+        producesDecisionRecommendation: false,
+        mandatedFacets: ["evidence", "assumptions"],
+        directives: [
+            "expand-option-space-before-converging",
+            "state-position-then-evidence",
+            "list-explicit-assumptions",
+        ],
+    },
+    "evidence-check": {
+        mode: "evidence-check",
+        challengesAssumptions: true,
+        requiresExplicitAssumptions: true,
+        requiresUncertaintyDisclosure: true,
+        citationDiscipline: "require-citations",
+        contradictionPolicy: "disclose-and-defer",
+        groundingDirectives: [
+            "attribute-claims-to-sources",
+            "do-not-fabricate-sources",
+            "stay-within-evidence",
+            "disclose-uncertainty",
+        ],
+        producesDecisionRecommendation: false,
+        mandatedFacets: ["evidence", "assumptions", "uncertainty"],
+        directives: [
+            "verify-claims-against-evidence",
+            "cite-evidence-or-state-none",
+            "list-explicit-assumptions",
+            "disclose-uncertainty-and-confidence",
+        ],
+    },
+};
+export function discussionModePlan(mode) {
+    return DISCUSSION_MODE_PLANS[mode];
+}
+// AC3 regression guard: true iff the union of the disagreement facets addressed by the plan's rendered
+// directives (via `DISCUSSION_DIRECTIVE_FACETS`) is a SUPERSET of the facets the plan mandates. In other
+// words, every facet the mode promises to cover has at least one directive in the rendered prompt that
+// instructs the model on it. A mandated facet with no covering directive — e.g. a `decide` plan that
+// mandates `evidence` but renders no evidence directive — makes this return false.
+export function discussionDirectivesCoverFacets(plan) {
+    const covered = new Set();
+    for (const directive of plan.directives) {
+        for (const facet of DISCUSSION_DIRECTIVE_FACETS[directive]) {
+            covered.add(facet);
+        }
+    }
+    return plan.mandatedFacets.every((facet) => covered.has(facet));
+}
+// ─── Capability gating (text-first + voice reuse, AC1/AC2) ───────────────────────
+// Discussion intelligence is ALWAYS available as text; this predicate only governs whether SPOKEN turns
+// may drive it. It reuses `voiceTranscriptCaptureAllowed` (the committed-transcript capability) so the
+// gating cannot drift from the voice contract: true for `speech-to-text`/`full-realtime`, false for
+// `none`/`speech-output` (playback-only). `none` keeps Keiko fully usable text-first (AC1).
+export function voiceCanDriveDiscussion(profile) {
+    return voiceTranscriptCaptureAllowed(profile);
+}
+export const DISCUSSION_TURN_STATUSES = [
+    "active",
+    "interrupted",
+    "recovered",
+    "resolved",
+];
+// Legal state-changing transitions, keyed by status for totality. `active` may be interrupted or
+// resolved directly; an `interrupted` turn recovers or resolves; a `recovered` turn may be interrupted
+// again (repeated barge-in) or resolved; `resolved` is terminal.
+export const DISCUSSION_TURN_STATUS_TRANSITIONS = {
+    active: ["interrupted", "resolved"],
+    interrupted: ["recovered", "resolved"],
+    recovered: ["interrupted", "resolved"],
+    resolved: [],
+};
+export function isDiscussionTurnStatus(value) {
+    return (typeof value === "string" && DISCUSSION_TURN_STATUSES.includes(value));
+}
+export function canTransitionDiscussionTurnStatus(from, to) {
+    return DISCUSSION_TURN_STATUS_TRANSITIONS[from].includes(to);
+}
+export function assertNeverDiscussionTurnStatus(value) {
+    throw new TypeError(`Unhandled DiscussionTurnStatus: ${JSON.stringify(value)}`);
+}
+// ─── topicId validation (opaque bounded safe-text id) ────────────────────────────
+// `topicId` is the open-question / decision identity — NEVER raw text. It is validated like the
+// prompt-enhancer branded ids (non-empty after trim, no surrounding whitespace, NFKC-normalised, no
+// control characters, ≤256, no path-traversal fragment) with a small LOCAL validator (the leaf rule
+// permits importing the prompt-enhancer one, but a local validator keeps this module self-contained and
+// avoids coupling the discussion identity to the enhancer's id brand).
+const DISCUSSION_TOPIC_ID_MAX_LENGTH = 256;
+const DISCUSSION_TOPIC_ID_FORBIDDEN_FRAGMENTS = ["..", "/", "\\"];
+function topicIdHasControlCharacter(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        // C0 controls 0x00–0x1F, DEL 0x7F, C1 controls 0x80–0x9F.
+        if (code <= 0x1f || code === 0x7f || (code >= 0x80 && code <= 0x9f)) {
+            return true;
+        }
+    }
+    return false;
+}
+// Collects ALL reasons a candidate topicId is invalid (accumulating, never throws). Empty array = valid.
+export function discussionTopicIdReasons(value) {
+    const reasons = [];
+    if (typeof value !== "string") {
+        return ["topicId: must be a string"];
+    }
+    if (value.length === 0 || value.trim().length === 0) {
+        reasons.push("topicId: must not be empty or whitespace-only");
+    }
+    if (value.length > 0 && value !== value.trim()) {
+        reasons.push("topicId: must not have surrounding whitespace");
+    }
+    if (value.length > DISCUSSION_TOPIC_ID_MAX_LENGTH) {
+        reasons.push("topicId: exceeds max length 256");
+    }
+    if (value.normalize("NFKC") !== value) {
+        reasons.push("topicId: must be NFKC-normalised");
+    }
+    if (topicIdHasControlCharacter(value)) {
+        reasons.push("topicId: contains control characters");
+    }
+    if (DISCUSSION_TOPIC_ID_FORBIDDEN_FRAGMENTS.some((fragment) => value.includes(fragment))) {
+        reasons.push("topicId: contains a forbidden path fragment");
+    }
+    return reasons;
+}
+export function isValidDiscussionTopicId(value) {
+    return discussionTopicIdReasons(value).length === 0;
+}
+// Pure constructor. Throws on an invalid topicId or a non-integer/negative turnIndex (boundary input),
+// keeping every constructed context well-formed; the transition helpers below never throw.
+export function beginDiscussionTurn(mode, topicId, turnIndex) {
+    const reasons = discussionTopicIdReasons(topicId);
+    if (reasons.length > 0) {
+        throw new TypeError(`Invalid discussion topicId: ${reasons.join("; ")}`);
+    }
+    if (!Number.isInteger(turnIndex) || turnIndex < 0) {
+        throw new TypeError(`Invalid discussion turnIndex: ${JSON.stringify(turnIndex)}`);
+    }
+    return {
+        schemaVersion: DISCUSSION_INTELLIGENCE_SCHEMA_VERSION,
+        mode,
+        topicId,
+        turnIndex,
+        status: "active",
+    };
+}
+// Returns a NEW context at the target status, preserving mode/topicId/turnIndex, when the transition is
+// legal; otherwise returns the input unchanged (the voice-transcript "snapshot, never throw" posture).
+function transitionDiscussionTurn(ctx, to) {
+    if (!canTransitionDiscussionTurnStatus(ctx.status, to)) {
+        return ctx;
+    }
+    return { ...ctx, status: to };
+}
+// AC4 load-bearing helpers. interrupt: active→interrupted; recover: interrupted→recovered with
+// mode/topicId/turnIndex UNCHANGED (the no-context-loss proof); resolve: →resolved.
+export function applyDiscussionInterruption(ctx) {
+    return transitionDiscussionTurn(ctx, "interrupted");
+}
+export function applyDiscussionRecovery(ctx) {
+    return transitionDiscussionTurn(ctx, "recovered");
+}
+export function resolveDiscussionTurn(ctx) {
+    return transitionDiscussionTurn(ctx, "resolved");
+}
+// Counts + enums only; never any topicId or text. An optional confidence score maps to a level via
+// `confidenceLevelFromScore`; when omitted the summary carries no confidence.
+export function summarizeDiscussionTurn(ctx, confidenceScore) {
+    const base = {
+        mode: ctx.mode,
+        status: ctx.status,
+        turnIndex: ctx.turnIndex,
+        mandatedFacetCount: DISCUSSION_MODE_PLANS[ctx.mode].mandatedFacets.length,
+    };
+    if (confidenceScore === undefined) {
+        return base;
+    }
+    return { ...base, confidence: confidenceLevelFromScore(confidenceScore) };
+}
+function buildDiscussionResult(reasons) {
+    return reasons.length === 0 ? { ok: true } : { ok: false, reasons };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function validateDiscussionTurnContext(value) {
+    if (!isRecord(value)) {
+        return { ok: false, reasons: ["context: must be an object"] };
+    }
+    const reasons = [];
+    if (!isDiscussionIntelligenceSchemaVersionSupported(value.schemaVersion)) {
+        reasons.push("schemaVersion: unsupported");
+    }
+    if (!isDiscussionMode(value.mode)) {
+        reasons.push("mode: unknown discussion mode");
+    }
+    for (const reason of discussionTopicIdReasons(value.topicId)) {
+        reasons.push(reason);
+    }
+    const turnIndex = value.turnIndex;
+    if (typeof turnIndex !== "number" || !Number.isInteger(turnIndex) || turnIndex < 0) {
+        reasons.push("turnIndex: must be a non-negative integer");
+    }
+    if (!isDiscussionTurnStatus(value.status)) {
+        reasons.push("status: unknown turn status");
+    }
+    return buildDiscussionResult(reasons);
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function validateModePlanFacets(mode, value, reasons) {
+    const disagreementCapable = mode !== "brainstorm";
+    const mandated = readStringArray(value);
+    for (const facet of DISAGREEMENT_FACETS) {
+        if (disagreementCapable && !mandated.includes(facet)) {
+            reasons.push(`mandatedFacets: ${mode} must mandate ${facet}`);
+        }
+    }
+}
+function validateModePlanDirectives(value, reasons) {
+    if (!Array.isArray(value) || value.length === 0) {
+        reasons.push("directives: must not be empty");
+        return;
+    }
+    for (const directive of value) {
+        if (typeof directive !== "string" ||
+            !DISCUSSION_DIRECTIVES.includes(directive)) {
+            reasons.push(`directives: unknown directive ${JSON.stringify(directive)}`);
+        }
+    }
+}
+export function validateDiscussionModePlan(value) {
+    if (!isRecord(value)) {
+        return { ok: false, reasons: ["plan: must be an object"] };
+    }
+    const mode = value.mode;
+    if (!isDiscussionMode(mode)) {
+        return { ok: false, reasons: ["mode: unknown discussion mode"] };
+    }
+    const reasons = [];
+    const canonical = DISCUSSION_MODE_PLANS[mode];
+    validateModePlanFacets(mode, value.mandatedFacets, reasons);
+    validateModePlanDirectives(value.directives, reasons);
+    if (value.producesDecisionRecommendation !== canonical.producesDecisionRecommendation) {
+        reasons.push("producesDecisionRecommendation: disagrees with canonical plan");
+    }
+    return buildDiscussionResult(reasons);
+}

package/dist/editor-agent-governance.d.ts

@@ -0,0 +1,65 @@
+import { type EditorAgentActionStatus, type EditorAgentActionType, type EditorAgentConflictCode, type EditorAgentFailureCode } from "./editor-agent.js";
+export declare const EDITOR_AGENT_AUDIT_SCHEMA_VERSION: "1";
+export declare const EDITOR_AGENT_AUDIT_SUMMARY_MAX_CHARS = 200;
+export type EditorAgentActionEffectClass = "navigation" | "layout" | "content-mutation" | "external-effect";
+export declare const EDITOR_AGENT_ACTION_EFFECT_CLASS: Readonly<Record<EditorAgentActionType, EditorAgentActionEffectClass>>;
+export declare function isMutatingEditorAgentAction(type: EditorAgentActionType): boolean;
+export type EditorAgentActionDisposition = "allowed" | "review-required" | "denied";
+export declare const EDITOR_AGENT_ACTION_DISPOSITIONS: readonly EditorAgentActionDisposition[];
+export type EditorAgentActionDenyReason = "workspace-boundary-escape" | "denied-sensitive-path";
+export declare const EDITOR_AGENT_ACTION_DENY_REASONS: readonly EditorAgentActionDenyReason[];
+export type EditorAgentActionReviewReason = "content-mutation-requires-review" | "external-effect-requires-review";
+export declare const EDITOR_AGENT_ACTION_REVIEW_REASONS: readonly EditorAgentActionReviewReason[];
+export interface EditorAgentActionPolicyDecision {
+    readonly disposition: EditorAgentActionDisposition;
+    readonly effectClass: EditorAgentActionEffectClass;
+    readonly denyReason?: EditorAgentActionDenyReason | undefined;
+    readonly reviewReason?: EditorAgentActionReviewReason | undefined;
+}
+export interface EditorAgentActionPolicyContext {
+    readonly targetPath: string | null;
+    readonly targetSensitive: boolean;
+}
+export declare function classifyEditorAgentAction(type: EditorAgentActionType, context: EditorAgentActionPolicyContext): EditorAgentActionPolicyDecision;
+export interface EditorAgentActionAuditRecord {
+    readonly schemaVersion: typeof EDITOR_AGENT_AUDIT_SCHEMA_VERSION;
+    readonly auditId: string;
+    readonly occurredAt: number;
+    readonly sessionId: string;
+    readonly actionId: string;
+    readonly actionType: EditorAgentActionType;
+    readonly effectClass: EditorAgentActionEffectClass;
+    readonly mutating: boolean;
+    readonly disposition: EditorAgentActionDisposition;
+    readonly denyReason?: EditorAgentActionDenyReason | undefined;
+    readonly reviewReason?: EditorAgentActionReviewReason | undefined;
+    readonly outcome: EditorAgentActionStatus;
+    readonly conflictCode?: EditorAgentConflictCode | undefined;
+    readonly failureCode?: EditorAgentFailureCode | undefined;
+    readonly targetPath?: string | undefined;
+    readonly editCount?: number | undefined;
+    readonly patchByteLength?: number | undefined;
+    readonly summary: string;
+}
+export interface EditorAgentActionAuditInput {
+    readonly auditId: string;
+    readonly occurredAt: number;
+    readonly sessionId: string;
+    readonly actionId: string;
+    readonly actionType: EditorAgentActionType;
+    readonly decision: EditorAgentActionPolicyDecision;
+    readonly outcome: EditorAgentActionStatus;
+    readonly conflictCode?: EditorAgentConflictCode | undefined;
+    readonly failureCode?: EditorAgentFailureCode | undefined;
+    readonly targetPath?: string | null | undefined;
+    readonly editCount?: number | undefined;
+    readonly patchByteLength?: number | undefined;
+}
+export declare function buildEditorAgentActionAuditRecord(input: EditorAgentActionAuditInput): EditorAgentActionAuditRecord;
+export interface EditorAgentAuditResponse {
+    readonly records: readonly EditorAgentActionAuditRecord[];
+}
+export declare function isEditorAgentActionDisposition(value: unknown): value is EditorAgentActionDisposition;
+export declare function isEditorAgentActionEffectClass(value: unknown): value is EditorAgentActionEffectClass;
+export declare function isEditorAgentActionAuditRecord(value: unknown): value is EditorAgentActionAuditRecord;
+//# sourceMappingURL=editor-agent-governance.d.ts.map

package/dist/editor-agent-governance.d.ts.map

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