@kontourai/survey 0.5.1 → 0.6.0

package/dist/src/review-authorizing.js

@@ -0,0 +1,125 @@
+const VALID_ACTIONS = new Set(["affirmed-control", "typed"]);
+/**
+ * Validates an `authorizing` block on a ReviewOutcome for admissibility.
+ *
+ * Per-kind required fields:
+ *   explicit-statement — `statement` (string, non-empty)
+ *   exchange           — `prompt` and `response` (both strings, non-empty;
+ *                        both halves required for self-contained testimony)
+ *   authorized-action  — `promptRef`, `renderedPrompt`, `action`, and
+ *                        `authorityRef` (all required; action must be
+ *                        "affirmed-control" or "typed")
+ *
+ * Returns an empty array when the block is valid.
+ */
+export function validateAuthorizing(block) {
+    if (block === null || typeof block !== "object" || Array.isArray(block)) {
+        return [{ code: "not-an-object", message: "authorizing block must be a plain object." }];
+    }
+    const record = block;
+    if (!("kind" in record) || record.kind === undefined) {
+        return [{ code: "missing-kind", message: "authorizing block is missing the required 'kind' field." }];
+    }
+    const kind = record.kind;
+    if (kind === "explicit-statement") {
+        return validateExplicitStatement(record);
+    }
+    if (kind === "exchange") {
+        return validateExchange(record);
+    }
+    if (kind === "authorized-action") {
+        return validateAuthorizedAction(record);
+    }
+    return [{
+            code: "unknown-kind",
+            message: `authorizing kind '${String(kind)}' is not admissible. Use 'explicit-statement', 'exchange', or 'authorized-action'.`,
+        }];
+}
+function validateExplicitStatement(block) {
+    const issues = [];
+    if (!block.statement || typeof block.statement !== "string" || block.statement.trim() === "") {
+        issues.push({
+            code: "missing-statement",
+            message: "explicit-statement authorizing block requires a non-empty 'statement' string.",
+        });
+    }
+    return issues;
+}
+function validateExchange(block) {
+    const issues = [];
+    if (!block.prompt || typeof block.prompt !== "string" || block.prompt.trim() === "") {
+        issues.push({
+            code: "missing-prompt",
+            message: "exchange authorizing block requires a non-empty 'prompt' string (both halves required for self-contained testimony).",
+        });
+    }
+    if (!block.response || typeof block.response !== "string" || block.response.trim() === "") {
+        issues.push({
+            code: "missing-response",
+            message: "exchange authorizing block requires a non-empty 'response' string (both halves required for self-contained testimony).",
+        });
+    }
+    return issues;
+}
+function validateAuthorizedAction(block) {
+    const issues = [];
+    if (!block.promptRef || typeof block.promptRef !== "string" || block.promptRef.trim() === "") {
+        issues.push({
+            code: "missing-prompt-ref",
+            message: "authorized-action authorizing block requires a non-empty 'promptRef' string.",
+        });
+    }
+    if (!block.renderedPrompt || typeof block.renderedPrompt !== "string" || block.renderedPrompt.trim() === "") {
+        issues.push({
+            code: "missing-rendered-prompt",
+            message: "authorized-action authorizing block requires a non-empty 'renderedPrompt' string.",
+        });
+    }
+    if (block.action === undefined) {
+        issues.push({
+            code: "missing-action",
+            message: "authorized-action authorizing block requires an 'action' field.",
+        });
+    }
+    else if (!VALID_ACTIONS.has(block.action)) {
+        issues.push({
+            code: "invalid-action",
+            message: `authorized-action 'action' must be 'affirmed-control' or 'typed'; received '${String(block.action)}'.`,
+        });
+    }
+    if (!block.authorityRef || typeof block.authorityRef !== "string" || block.authorityRef.trim() === "") {
+        issues.push({
+            code: "missing-authority-ref",
+            message: "authorized-action authorizing block requires a non-empty 'authorityRef' string linking an AuthorityTrace.",
+        });
+    }
+    return issues;
+}
+/**
+ * Type guard: returns true if a ReviewAuthorizing block passes all validation checks.
+ */
+export function isValidAuthorizing(block) {
+    return validateAuthorizing(block).length === 0;
+}
+/**
+ * Helper for consumers building `authorized-action` authorizing blocks outside
+ * the workbench. Constructs the block and validates it; throws if the result
+ * would be invalid so callers catch configuration errors at build time.
+ *
+ * For workbench-internal construction, use the workbench path directly — it
+ * runs validateAuthorizing and degrades gracefully instead of throwing.
+ */
+export function buildAuthorizedActionAuthorizing(input) {
+    const block = {
+        kind: "authorized-action",
+        promptRef: input.promptRef,
+        renderedPrompt: input.renderedPrompt,
+        action: input.action,
+        authorityRef: input.authorityRef,
+    };
+    const issues = validateAuthorizedAction(block);
+    if (issues.length > 0) {
+        throw new Error(`buildAuthorizedActionAuthorizing: invalid authorized-action block: ${issues.map((issue) => issue.message).join(" ")}`);
+    }
+    return block;
+}

package/dist/src/review-resource.d.ts

@@ -1,4 +1,4 @@
-import type { CandidateSetStatus, ClaimTarget, Extraction, RawSource, ReviewOutcome } from "./types.js";
+import type { CandidateSetStatus, ClaimTarget, Extraction, RawSource, ReviewAuthorizing, ReviewOutcome } from "./types.js";
 export declare const reviewResourceApiVersion = "survey.kontourai.io/v1alpha1";
 export type ReviewResourceApiVersion = typeof reviewResourceApiVersion;
 export type ReviewResourceKind = "ReviewItem" | "ReviewDecision" | "ReviewSession" | "ReviewSessionEvent";
@@ -102,6 +102,10 @@ export interface ReviewDecisionSpec {
     evidenceIds?: string[];
     withinComfortZone?: boolean;
     comfortZoneNote?: string;
+    /** Optional testimony provenance. Populated by the workbench on the
+     *  `authorized-action` channel; consumers on other channels may supply
+     *  their own admissible block. */
+    authorizing?: ReviewAuthorizing;
     projection?: SurveyRecordProjectionHint;
 }
 export interface ReviewDecisionStatus {

package/dist/src/review-workbench/review-workbench-css.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const REVIEW_WORKBENCH_CSS: string;
+export default REVIEW_WORKBENCH_CSS;