@oscharko-dev/keiko-contracts 0.2.0

package/dist/prompt-enhancer-bff.d.ts

@@ -0,0 +1,67 @@
+import type { CostClass } from "./gateway.js";
+import { type EnhancedPrompt, type MissingInformationStrategy, type PromptEnhancementProfileId, type PromptTaskAnalysis, PROMPT_ENHANCER_SCHEMA_VERSION } from "./prompt-enhancer.js";
+import type { PromptCandidateRejection, PromptCandidateScorecard } from "./prompt-enhancer-critic.js";
+import type { PromptSafetyAssessment } from "./prompt-enhancer-safety.js";
+import { type PromptEnhancerValidation } from "./prompt-enhancer-validation.js";
+export declare const PROMPT_ENHANCEMENT_LOCALE_MAX_CHARS: 35;
+export declare const PROMPT_ENHANCEMENT_MODEL_ID_MAX_CHARS: 200;
+export declare const PROMPT_ENHANCEMENT_DEFAULT_CANDIDATE_COUNT: 3;
+export declare const PROMPT_ENHANCEMENT_MAX_CANDIDATE_COUNT: 7;
+export interface PromptEnhancementWireRequest {
+    readonly text: string;
+    readonly profilePreference?: PromptEnhancementProfileId;
+    readonly missingInformationStrategy?: MissingInformationStrategy;
+    readonly hasConnectedContext?: boolean;
+    readonly attachmentCount?: number;
+    readonly locale?: string;
+    readonly modelId?: string;
+    readonly candidateCount?: number;
+}
+export type PromptEnhancementModelAvailability = "available" | "unavailable" | "not-requested";
+export declare const PROMPT_ENHANCEMENT_MODEL_AVAILABILITIES: readonly PromptEnhancementModelAvailability[];
+export type PromptEnhancementModelRoutingReason = "no-model-requested" | "model-available" | "no-gateway-config" | "model-not-configured" | "model-not-chat-capable";
+export interface PromptEnhancementModelRouting {
+    readonly availability: PromptEnhancementModelAvailability;
+    readonly reason: PromptEnhancementModelRoutingReason;
+    readonly requestedModelId?: string;
+    readonly resolvedModelId?: string;
+    readonly costClass?: CostClass;
+}
+export interface PromptEnhancementCandidateComparison {
+    readonly winnerCandidateId: string;
+    readonly scorecards: readonly PromptCandidateScorecard[];
+    readonly rejected: readonly PromptCandidateRejection[];
+}
+export type PromptEnhancementGroundingReadinessStatus = "not-required" | "ready" | "unavailable";
+export type PromptEnhancementGroundingReadinessReason = "no-grounding-required" | "connected-context-present" | "missing-concrete-scope";
+export interface PromptEnhancementGroundingReadiness {
+    readonly status: PromptEnhancementGroundingReadinessStatus;
+    readonly reason: PromptEnhancementGroundingReadinessReason;
+    readonly notice?: string;
+}
+export type PromptEnhancementEvidenceReferenceStatus = "recorded" | "not-recorded";
+export type PromptEnhancementEvidenceReferenceReason = "evidence-recorded" | "evidence-store-not-configured";
+export interface PromptEnhancementEvidenceReference {
+    readonly status: PromptEnhancementEvidenceReferenceStatus;
+    readonly reason: PromptEnhancementEvidenceReferenceReason;
+    readonly runId?: string;
+    readonly manifestUrl?: string;
+    readonly manifestLocation?: string;
+    readonly peEvidenceSchemaVersion?: number;
+    readonly recordIntegritySha256?: string;
+}
+export interface PromptEnhancementWireResponse {
+    readonly schemaVersion: typeof PROMPT_ENHANCER_SCHEMA_VERSION;
+    readonly promptId: string;
+    readonly inputFingerprintSha256: string;
+    readonly analysis: PromptTaskAnalysis;
+    readonly enhancedPrompt: EnhancedPrompt;
+    readonly renderedPrompt: string;
+    readonly candidates: PromptEnhancementCandidateComparison;
+    readonly safety: PromptSafetyAssessment;
+    readonly modelRouting: PromptEnhancementModelRouting;
+    readonly groundingReadiness: PromptEnhancementGroundingReadiness;
+    readonly evidence: PromptEnhancementEvidenceReference;
+}
+export declare function validatePromptEnhancementWireRequest(input: unknown): PromptEnhancerValidation<PromptEnhancementWireRequest>;
+//# sourceMappingURL=prompt-enhancer-bff.d.ts.map

package/dist/prompt-enhancer-bff.d.ts.map

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

package/dist/prompt-enhancer-bff.js

@@ -0,0 +1,156 @@
+// Prompt Enhancer BFF wire contracts (Epic #1307, Issue #1314; governed by ADR-0044 §1 row "BFF
+// /api/prompt-enhancer/* routes"). These shapes travel over the HTTP wire between the keiko-server
+// BFF and the React UI / CLI surfaces, exactly like the entity wire types in `bff-wire.ts`.
+//
+// Scope discipline. #1314 is a SURFACE issue: it exposes the deterministic enhancer core (#1309 –
+// #1313) through a governed API, CLI, and UI. This module therefore adds ONLY the request/response
+// envelope and a pure request validator. It introduces no new domain behaviour and no model-execution
+// parameters. The response composes the already content-light, provider-neutral artefacts produced by
+// the existing pipeline (`PromptTaskAnalysis`, `EnhancedPrompt`, `PromptCandidateScorecard`,
+// `PromptSafetyAssessment`) and adds a Model-Gateway readiness/routing descriptor (AC3).
+//
+// Trust boundary (ADR-0044 §5). Like every prompt-enhancer contract, these shapes carry no provider
+// credential, hidden system prompt, or tool/secret/egress/patch authority grant. The wire request is
+// the untrusted user draft plus bounded, validated metadata; the server mints the branded ids and runs
+// the deterministic pipeline. Leaf-package rule (ADR-0019 direction 1): no `@oscharko-dev/keiko-*`
+// import; same-package relative imports only.
+import { stripUnsafeFormatChars } from "./text-safety.js";
+import { MISSING_INFORMATION_STRATEGIES, PROMPT_ENHANCEMENT_PROFILE_IDS, PROMPT_ENHANCER_SCHEMA_VERSION, } from "./prompt-enhancer.js";
+import { PROMPT_REQUEST_TEXT_MAX_CHARS, } from "./prompt-enhancer-validation.js";
+// ─── Bounds ──────────────────────────────────────────────────────────────────────
+// A BCP-47-ish locale tag is informational only; bound it to the same ceiling the domain validator
+// uses. The candidate-count ceiling mirrors the profile-slate size (one candidate per profile); the
+// server additionally clamps to the gateway's own `MAX_CANDIDATE_COUNT` so the wire never widens the
+// optimization envelope.
+export const PROMPT_ENHANCEMENT_LOCALE_MAX_CHARS = 35;
+export const PROMPT_ENHANCEMENT_MODEL_ID_MAX_CHARS = 200;
+export const PROMPT_ENHANCEMENT_DEFAULT_CANDIDATE_COUNT = 3;
+export const PROMPT_ENHANCEMENT_MAX_CANDIDATE_COUNT = 7;
+export const PROMPT_ENHANCEMENT_MODEL_AVAILABILITIES = ["available", "unavailable", "not-requested"];
+// ─── Pure request validator ────────────────────────────────────────────────────────────
+// Mirrors the discriminated-result discipline of `prompt-enhancer-validation.ts`: pure, never throws,
+// one short machine-readable error per failed invariant, never echoes raw input.
+const WIRE_REQUEST_KEYS = new Set([
+    "text",
+    "profilePreference",
+    "missingInformationStrategy",
+    "hasConnectedContext",
+    "attachmentCount",
+    "locale",
+    "modelId",
+    "candidateCount",
+]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isMember = (value, allowed) => typeof value === "string" && allowed.includes(value);
+const isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+const isBoundedSafeText = (value, max) => typeof value === "string" && value.length <= max && stripUnsafeFormatChars(value) === value;
+const validateUnknownFields = (input, errors) => {
+    if (Object.keys(input).some((key) => !WIRE_REQUEST_KEYS.has(key))) {
+        errors.push("request must not contain unknown fields");
+    }
+};
+const validateTextField = (input, errors) => {
+    if (typeof input.text !== "string") {
+        errors.push("request.text must be a string");
+    }
+    else if (input.text.trim().length === 0) {
+        errors.push("request.text must not be empty or whitespace-only");
+    }
+    else if (input.text.length > PROMPT_REQUEST_TEXT_MAX_CHARS) {
+        errors.push(`request.text must be at most ${String(PROMPT_REQUEST_TEXT_MAX_CHARS)} characters`);
+    }
+};
+const validateProfileField = (input, errors) => {
+    if (input.profilePreference !== undefined &&
+        !isMember(input.profilePreference, PROMPT_ENHANCEMENT_PROFILE_IDS)) {
+        errors.push("request.profilePreference must be a known profile id when set");
+    }
+};
+const validateStrategyField = (input, errors) => {
+    if (input.missingInformationStrategy !== undefined &&
+        !isMember(input.missingInformationStrategy, MISSING_INFORMATION_STRATEGIES)) {
+        errors.push("request.missingInformationStrategy must be a known strategy when set");
+    }
+};
+const validateConnectedContextField = (input, errors) => {
+    if (input.hasConnectedContext !== undefined && typeof input.hasConnectedContext !== "boolean") {
+        errors.push("request.hasConnectedContext must be a boolean when set");
+    }
+};
+const validateAttachmentCountField = (input, errors) => {
+    if (input.attachmentCount !== undefined && !isNonNegativeInteger(input.attachmentCount)) {
+        errors.push("request.attachmentCount must be a non-negative integer when set");
+    }
+};
+const validateLocaleField = (input, errors) => {
+    if (input.locale !== undefined &&
+        !isBoundedSafeText(input.locale, PROMPT_ENHANCEMENT_LOCALE_MAX_CHARS)) {
+        errors.push(`request.locale must be safe text of at most ${String(PROMPT_ENHANCEMENT_LOCALE_MAX_CHARS)} characters when set`);
+    }
+};
+const validateModelIdField = (input, errors) => {
+    if (input.modelId !== undefined &&
+        (!isBoundedSafeText(input.modelId, PROMPT_ENHANCEMENT_MODEL_ID_MAX_CHARS) ||
+            input.modelId.trim().length === 0)) {
+        errors.push(`request.modelId must be non-empty safe text of at most ${String(PROMPT_ENHANCEMENT_MODEL_ID_MAX_CHARS)} characters when set`);
+    }
+};
+const validateCandidateCountField = (input, errors) => {
+    const value = input.candidateCount;
+    if (value !== undefined &&
+        (typeof value !== "number" ||
+            !Number.isInteger(value) ||
+            value < 1 ||
+            value > PROMPT_ENHANCEMENT_MAX_CANDIDATE_COUNT)) {
+        errors.push(`request.candidateCount must be an integer in [1, ${String(PROMPT_ENHANCEMENT_MAX_CANDIDATE_COUNT)}] when set`);
+    }
+};
+const WIRE_FIELD_VALIDATORS = [
+    validateUnknownFields,
+    validateTextField,
+    validateProfileField,
+    validateStrategyField,
+    validateConnectedContextField,
+    validateAttachmentCountField,
+    validateLocaleField,
+    validateModelIdField,
+    validateCandidateCountField,
+];
+// Assemble the validated wire request, omitting absent optionals so exactOptionalPropertyTypes holds.
+function buildWireRequestValue(input) {
+    return {
+        text: input.text,
+        ...(input.profilePreference === undefined
+            ? {}
+            : { profilePreference: input.profilePreference }),
+        ...(input.missingInformationStrategy === undefined
+            ? {}
+            : {
+                missingInformationStrategy: input.missingInformationStrategy,
+            }),
+        ...(input.hasConnectedContext === undefined
+            ? {}
+            : { hasConnectedContext: input.hasConnectedContext }),
+        ...(input.attachmentCount === undefined
+            ? {}
+            : { attachmentCount: input.attachmentCount }),
+        ...(input.locale === undefined ? {} : { locale: input.locale }),
+        ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
+        ...(input.candidateCount === undefined
+            ? {}
+            : { candidateCount: input.candidateCount }),
+    };
+}
+export function validatePromptEnhancementWireRequest(input) {
+    if (!isRecord(input)) {
+        return { ok: false, errors: ["request must be an object"] };
+    }
+    const errors = [];
+    for (const validate of WIRE_FIELD_VALIDATORS) {
+        validate(input, errors);
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true, value: buildWireRequestValue(input) };
+}

package/dist/prompt-enhancer-critic.d.ts

@@ -0,0 +1,46 @@
+import { PROMPT_ENHANCER_SCHEMA_VERSION, type EnhancedPrompt, type PromptEnhancementProfileId } from "./prompt-enhancer.js";
+import type { PromptSafetyAssessment } from "./prompt-enhancer-safety.js";
+export type PromptCriticDimension = "clarity" | "completeness" | "grounding-readiness" | "safety" | "output-controllability" | "token-efficiency";
+export declare const PROMPT_CRITIC_DIMENSIONS: readonly PromptCriticDimension[];
+export declare const isPromptCriticDimension: (value: unknown) => value is PromptCriticDimension;
+export interface PromptCriticDimensionScore {
+    readonly dimension: PromptCriticDimension;
+    readonly score: number;
+    readonly rationale: string;
+}
+export interface PromptCandidateScorecard {
+    readonly schemaVersion: typeof PROMPT_ENHANCER_SCHEMA_VERSION;
+    readonly candidateId: string;
+    readonly profile: PromptEnhancementProfileId;
+    readonly dimensionScores: readonly PromptCriticDimensionScore[];
+    readonly aggregateScore: number;
+    readonly estimatedTokens: number;
+}
+export type PromptCandidateRejectionReason = "lower-aggregate-score" | "lower-tie-break-rank" | "exceeded-token-budget" | "duplicate-candidate" | "safety-floor-not-preserved" | "safety-validation-failed";
+export declare const PROMPT_CANDIDATE_REJECTION_REASONS: readonly PromptCandidateRejectionReason[];
+export declare const isPromptCandidateRejectionReason: (value: unknown) => value is PromptCandidateRejectionReason;
+export interface PromptCandidateRejection {
+    readonly candidateId: string;
+    readonly profile: PromptEnhancementProfileId;
+    readonly aggregateScore: number | null;
+    readonly reason: PromptCandidateRejectionReason;
+}
+export interface PromptOptimizationBounds {
+    readonly candidateCount: number;
+    readonly tokenBudget: number;
+    readonly maxIterations: number;
+}
+export interface PromptCandidateSelection {
+    readonly schemaVersion: typeof PROMPT_ENHANCER_SCHEMA_VERSION;
+    readonly winner: PromptCandidateScorecard;
+    readonly ranked: readonly PromptCandidateScorecard[];
+    readonly rankedPrompts: readonly EnhancedPrompt[];
+    readonly winnerSafetyAssessment: PromptSafetyAssessment;
+    readonly rankedSafetyAssessments: readonly PromptSafetyAssessment[];
+    readonly rejected: readonly PromptCandidateRejection[];
+    readonly bounds: PromptOptimizationBounds;
+    readonly iterations: number;
+    readonly candidatesConsidered: number;
+    readonly tokensConsumed: number;
+}
+//# sourceMappingURL=prompt-enhancer-critic.d.ts.map

package/dist/prompt-enhancer-critic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-enhancer-critic.d.ts","sourceRoot":"","sources":["../src/prompt-enhancer-critic.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,8BAA8B,EAC9B,KAAK,cAAc,EACnB,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAM1E,MAAM,MAAM,qBAAqB,GAC7B,SAAS,GACT,cAAc,GACd,qBAAqB,GACrB,QAAQ,GACR,wBAAwB,GACxB,kBAAkB,CAAC;AAEvB,eAAO,MAAM,wBAAwB,EAAE,SAAS,qBAAqB,EAO3D,CAAC;AAEX,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,qBAC4B,CAAC;AAM/F,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,SAAS,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAKD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,aAAa,EAAE,OAAO,8BAA8B,CAAC;IAE9D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;IAE7C,QAAQ,CAAC,eAAe,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAEhE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAGhC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAGD,MAAM,MAAM,8BAA8B,GAEtC,uBAAuB,GAEvB,sBAAsB,GAEtB,uBAAuB,GAEvB,qBAAqB,GAGrB,4BAA4B,GAE5B,0BAA0B,CAAC;AAE/B,eAAO,MAAM,kCAAkC,EAAE,SAAS,8BAA8B,EAO9E,CAAC;AAEX,eAAO,MAAM,gCAAgC,GAC3C,OAAO,OAAO,KACb,KAAK,IAAI,8BAE+D,CAAC;AAI5E,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,8BAA8B,CAAC;CACjD;AAOD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAMD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,aAAa,EAAE,OAAO,8BAA8B,CAAC;IAC9D,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,SAAS,cAAc,EAAE,CAAC;IAClD,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB,CAAC;IACxD,QAAQ,CAAC,uBAAuB,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACpE,QAAQ,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACvD,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAE1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC"}

package/dist/prompt-enhancer-critic.js

@@ -0,0 +1,35 @@
+// Prompt Enhancer candidate-critic contract surface (Epic #1307, Issue #1312; ADR-0044 §1/§6).
+//
+// Wire-safe, provider-neutral type shapes for the deterministic PromptCritic: the scoring dimensions,
+// a transparent per-candidate scorecard, the auditable selection result of the bounded optimization
+// loop, and the configured optimization bounds. The deterministic scoring *logic* lives in the model
+// gateway (`keiko-model-gateway/src/promptEnhancer/critic.ts`); this module owns only the contract
+// shapes so the server (#1314) and offline evaluation suite (#1315) can transmit and render scorecards
+// without re-deriving them.
+//
+// These dimensions are deliberately a distinct set from the agent-run-trajectory `EVALUATION_DIMENSIONS`
+// (`evaluations.ts`): those score a completed workflow run pass/fail, whereas these score the *quality
+// of an Enhanced Prompt artefact* on a continuous [0, 1] scale so candidates can be ranked.
+//
+// Determinism: pure value tables and types only. No IO, clock, randomness, or module-level side
+// effects. Leaf-package rule (ADR-0019 direction 1): no `@oscharko-dev/keiko-*` imports.
+import { PROMPT_ENHANCER_SCHEMA_VERSION, } from "./prompt-enhancer.js";
+export const PROMPT_CRITIC_DIMENSIONS = [
+    "clarity",
+    "completeness",
+    "grounding-readiness",
+    "safety",
+    "output-controllability",
+    "token-efficiency",
+];
+export const isPromptCriticDimension = (value) => typeof value === "string" && PROMPT_CRITIC_DIMENSIONS.includes(value);
+export const PROMPT_CANDIDATE_REJECTION_REASONS = [
+    "lower-aggregate-score",
+    "lower-tie-break-rank",
+    "exceeded-token-budget",
+    "duplicate-candidate",
+    "safety-floor-not-preserved",
+    "safety-validation-failed",
+];
+export const isPromptCandidateRejectionReason = (value) => typeof value === "string" &&
+    PROMPT_CANDIDATE_REJECTION_REASONS.includes(value);

package/dist/prompt-enhancer-grounding.d.ts

@@ -0,0 +1,19 @@
+import { type GroundingDirective, type GroundingPlan, type GroundingSourceKind, type GroundingSourcePolicy, type GroundingStrategy, type NoAnswerCondition, type PromptEnhancementProfileId, type PromptTaskAnalysis, type RagEvaluationDimension, type RetrievalMode } from "./prompt-enhancer.js";
+export declare const SOURCE_PRIORITY_BY_STRATEGY: Readonly<Record<GroundingStrategy, readonly GroundingSourceKind[]>>;
+export declare const RETRIEVAL_MODES_BY_STRATEGY: Readonly<Record<GroundingStrategy, readonly RetrievalMode[]>>;
+export declare function buildSourcePriority(strategy: GroundingStrategy, required: boolean): readonly GroundingSourcePolicy[];
+export declare const MULTI_SOURCE_STRATEGIES: ReadonlySet<GroundingStrategy>;
+export declare const SCOPED_EVIDENCE_STRATEGIES: ReadonlySet<GroundingStrategy>;
+export declare function buildNoAnswerConditions(strategy: GroundingStrategy, analysis: PromptTaskAnalysis): readonly NoAnswerCondition[];
+export declare function buildDirectives(strategy: GroundingStrategy, required: boolean): readonly GroundingDirective[];
+export declare const RAG_HINT_TEMPLATES: Readonly<Record<RagEvaluationDimension, string>>;
+export interface PlanGroundingOptions {
+    readonly profile?: PromptEnhancementProfileId | undefined;
+}
+/**
+ * Build a deterministic `GroundingPlan` from a `PromptTaskAnalysis`. Pure: identical analyses/options
+ * always produce an identical plan. The plan is a provider-neutral source policy; it never performs or
+ * authorizes retrieval.
+ */
+export declare function planGrounding(analysis: PromptTaskAnalysis, options?: PlanGroundingOptions): GroundingPlan;
+//# sourceMappingURL=prompt-enhancer-grounding.d.ts.map

package/dist/prompt-enhancer-grounding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-enhancer-grounding.d.ts","sourceRoot":"","sources":["../src/prompt-enhancer-grounding.ts"],"names":[],"mappings":"AAYA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EAEvB,KAAK,sBAAsB,EAG3B,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AA4D9B,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAChD,MAAM,CAAC,iBAAiB,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAiB1D,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAChD,MAAM,CAAC,iBAAiB,EAAE,SAAS,aAAa,EAAE,CAAC,CAQpD,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,OAAO,GAChB,SAAS,qBAAqB,EAAE,CAQlC;AAwDD,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,iBAAiB,CAKjE,CAAC;AAEH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,iBAAiB,CAIpE,CAAC;AAEH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,kBAAkB,GAC3B,SAAS,iBAAiB,EAAE,CAe9B;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,OAAO,GAChB,SAAS,kBAAkB,EAAE,CAoB/B;AAkBD,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAW/E,CAAC;AAgBF,MAAM,WAAW,oBAAoB;IAGnC,QAAQ,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;CAC3D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,oBAAyB,GACjC,aAAa,CAkBf"}

package/dist/prompt-enhancer-grounding.js

@@ -0,0 +1,235 @@
+// Deterministic Prompt Enhancer grounding planner (Issue #1311, ADR-0044 §1/§5 / blueprint §6).
+//
+// `planGrounding` turns a normalized `PromptTaskAnalysis` (#1309) into a structured `GroundingPlan`:
+// a provider-neutral source POLICY (which sources, in what priority, with what citation/contradiction/
+// uncertainty discipline and which RAG evaluation hints). It performs NO retrieval — actual grounding
+// stays in the existing Keiko paths (Local Knowledge / repository context / hybrid RRF, ADR-0034/0036),
+// bound to the plan by the server (#1314). The planner is pure: identical analyses always yield an
+// identical plan; no model call, IO, clock read, or randomness; no raw input text is echoed.
+//
+// Leaf-package rule (ADR-0019 direction 1): no `@oscharko-dev/keiko-*` imports. Only the same-package
+// contract surface in `./prompt-enhancer.js` is consumed.
+import { PROMPT_ENHANCEMENT_PROFILES, RAG_EVALUATION_DIMENSIONS, } from "./prompt-enhancer.js";
+// ─── Strategy selection ────────────────────────────────────────────────────────────
+// The code-oriented task classes whose external-knowledge grounding is best served by the repository
+// context rather than a document store.
+const CODE_TASK_CLASSES = new Set([
+    "code-generation",
+    "code-debugging",
+    "code-architecture",
+]);
+function selectExternalKnowledgeStrategy(analysis) {
+    if (analysis.taskClass === "rag-question-answering") {
+        return "local-knowledge";
+    }
+    if (analysis.domain === "software" || CODE_TASK_CLASSES.has(analysis.taskClass)) {
+        return "repository-context";
+    }
+    // Research, decision support, and other knowledge-intensive tasks combine the available sources.
+    return "hybrid";
+}
+// Map the analyzer's grounding-need kind to a concrete grounding strategy. The four need kinds map
+// directly except `external-knowledge`, which is refined by task class / domain into the
+// local-knowledge / repository-context / hybrid strategies.
+function selectStrategy(analysis) {
+    switch (analysis.groundingNeed.kind) {
+        case "none":
+            return "no-grounding";
+        case "supplied-context":
+            return "supplied-context-only";
+        case "external-current":
+            return "external-research-required";
+        case "external-knowledge":
+            return selectExternalKnowledgeStrategy(analysis);
+    }
+}
+// Whether grounded evidence is required for an acceptable answer. Retrieval-bound strategies always
+// require it; a hybrid plan requires it only when the profile mandates grounding or the user connected
+// context; `no-grounding` never does (the model answers from stable knowledge under discipline).
+function isGroundingRequired(strategy, groundingMandatory, connected) {
+    switch (strategy) {
+        case "no-grounding":
+            return false;
+        case "supplied-context-only":
+        case "local-knowledge":
+        case "repository-context":
+        case "external-research-required":
+            return true;
+        case "hybrid":
+            return groundingMandatory || connected;
+    }
+}
+// ─── Source priority + allowed retrieval modes ─────────────────────────────────────
+export const SOURCE_PRIORITY_BY_STRATEGY = {
+    "no-grounding": ["model-parametric-knowledge"],
+    "supplied-context-only": ["supplied-context", "model-parametric-knowledge"],
+    "local-knowledge": ["local-knowledge", "supplied-context", "model-parametric-knowledge"],
+    "repository-context": ["repository-context", "supplied-context", "model-parametric-knowledge"],
+    hybrid: [
+        "supplied-context",
+        "local-knowledge",
+        "repository-context",
+        "model-parametric-knowledge",
+    ],
+    "external-research-required": [
+        "external-current",
+        "supplied-context",
+        "model-parametric-knowledge",
+    ],
+};
+export const RETRIEVAL_MODES_BY_STRATEGY = {
+    "no-grounding": ["none"],
+    "supplied-context-only": ["supplied-context"],
+    "local-knowledge": ["local-knowledge-retrieval", "supplied-context"],
+    "repository-context": ["repository-search", "supplied-context"],
+    hybrid: ["hybrid-fusion", "local-knowledge-retrieval", "repository-search", "supplied-context"],
+    "external-research-required": ["external-research", "supplied-context"],
+};
+export function buildSourcePriority(strategy, required) {
+    return SOURCE_PRIORITY_BY_STRATEGY[strategy].map((source, index) => ({
+        source,
+        priority: index + 1,
+        // Only the top non-parametric source is mandatory, and only when the plan requires grounding;
+        // parametric knowledge is always an optional fallback, never a required source.
+        required: required && index === 0 && source !== "model-parametric-knowledge",
+    }));
+}
+// ─── Citation, recency, contradiction ──────────────────────────────────────────────
+function isSafetyCriticalAnalysis(analysis) {
+    return analysis.criticality === "critical" || analysis.taskClass === "safety-critical";
+}
+function buildCitationRequirement(strategy, analysis, required) {
+    if (strategy === "no-grounding") {
+        return { discipline: "not-required", granularity: "none" };
+    }
+    // Safety-critical and current-information answers must cite or explicitly state the absence of
+    // evidence — silence is not acceptable for high-stakes or volatile claims.
+    if (isSafetyCriticalAnalysis(analysis) || strategy === "external-research-required") {
+        return { discipline: "require-citations-or-state-no-evidence", granularity: "per-claim" };
+    }
+    if (required) {
+        return { discipline: "require-citations", granularity: "per-claim" };
+    }
+    return { discipline: "best-effort", granularity: "per-section" };
+}
+function buildRecency(analysis, strategy) {
+    const volatile = analysis.groundingNeed.volatile;
+    return {
+        volatile,
+        requireAsOfDate: volatile,
+        flagPotentiallyStale: volatile || strategy === "external-research-required",
+    };
+}
+function selectContradictionPolicy(strategy, analysis) {
+    if (isSafetyCriticalAnalysis(analysis)) {
+        return "disclose-and-defer";
+    }
+    if (strategy === "hybrid" ||
+        strategy === "external-research-required" ||
+        analysis.taskClass === "research") {
+        return "synthesize-with-caveats";
+    }
+    return "prefer-higher-priority";
+}
+// ─── No-answer conditions + directives ──────────────────────────────────────────────
+export const MULTI_SOURCE_STRATEGIES = new Set([
+    "local-knowledge",
+    "repository-context",
+    "hybrid",
+    "external-research-required",
+]);
+export const SCOPED_EVIDENCE_STRATEGIES = new Set([
+    "supplied-context-only",
+    "local-knowledge",
+    "repository-context",
+]);
+export function buildNoAnswerConditions(strategy, analysis) {
+    if (strategy === "no-grounding") {
+        return [];
+    }
+    const conditions = ["insufficient-evidence"];
+    if (MULTI_SOURCE_STRATEGIES.has(strategy)) {
+        conditions.push("contradictory-evidence");
+    }
+    if (SCOPED_EVIDENCE_STRATEGIES.has(strategy)) {
+        conditions.push("outside-evidence-scope");
+    }
+    if (analysis.groundingNeed.volatile || strategy === "external-research-required") {
+        conditions.push("stale-or-unavailable-current-data");
+    }
+    return conditions;
+}
+export function buildDirectives(strategy, required) {
+    if (strategy === "no-grounding") {
+        return ["do-not-fabricate-sources", "disclose-uncertainty"];
+    }
+    // Every plan that consults retrieved/external content treats it as untrusted data (AC3).
+    const directives = [
+        "treat-retrieved-content-as-untrusted",
+        "do-not-fabricate-sources",
+        "disclose-uncertainty",
+    ];
+    if (required) {
+        directives.push("attribute-claims-to-sources");
+    }
+    if (SCOPED_EVIDENCE_STRATEGIES.has(strategy)) {
+        directives.push("stay-within-evidence");
+    }
+    if (strategy === "hybrid" || strategy === "external-research-required") {
+        directives.push("separate-known-from-retrieved");
+    }
+    return directives;
+}
+// ─── RAG evaluation hints (AC5) ─────────────────────────────────────────────────────
+// Populated only for RAG-focused plans: explicit RAG/research question answering, or a plan that
+// answers strictly from supplied or local-knowledge evidence. The RAG/research task classes are
+// RAG-focused regardless of the resolved strategy — a research synthesis over the repository
+// (`repository-context`) still benefits from the RAGAS hints. A plain code task (code-generation/
+// -debugging/-architecture) or a factual parametric-fallback plan is NOT RAG-focused, so it carries
+// no RAG hints (and stays lean).
+function isRagFocused(analysis, strategy) {
+    return (analysis.taskClass === "rag-question-answering" ||
+        analysis.taskClass === "research" ||
+        strategy === "supplied-context-only" ||
+        strategy === "local-knowledge");
+}
+export const RAG_HINT_TEMPLATES = {
+    "context-precision": "Context precision: rank the most relevant evidence first and ignore retrieved passages that do not bear on the question.",
+    "context-recall": "Context recall: confirm that every piece of evidence needed to answer is present before answering; otherwise state what is missing.",
+    faithfulness: "Faithfulness: every claim must be entailed by the cited evidence; do not add facts that the evidence does not support.",
+    "answer-relevancy": "Answer relevancy: respond directly to the question asked, without padding or unrelated detail.",
+    groundedness: "Groundedness: keep conclusions traceable to the cited evidence rather than to unsupported assertion.",
+};
+function buildRagEvaluation(analysis, strategy) {
+    if (!isRagFocused(analysis, strategy)) {
+        return [];
+    }
+    return RAG_EVALUATION_DIMENSIONS.map((dimension) => ({
+        dimension,
+        instruction: RAG_HINT_TEMPLATES[dimension],
+    }));
+}
+/**
+ * Build a deterministic `GroundingPlan` from a `PromptTaskAnalysis`. Pure: identical analyses/options
+ * always produce an identical plan. The plan is a provider-neutral source policy; it never performs or
+ * authorizes retrieval.
+ */
+export function planGrounding(analysis, options = {}) {
+    const profile = PROMPT_ENHANCEMENT_PROFILES[options.profile ?? analysis.recommendedProfile];
+    const connected = analysis.groundingNeed.signals.includes("supplied-context-reference");
+    const strategy = selectStrategy(analysis);
+    const required = isGroundingRequired(strategy, profile.groundingMandatory, connected);
+    return {
+        strategy,
+        required,
+        allowedRetrievalModes: [...RETRIEVAL_MODES_BY_STRATEGY[strategy]],
+        sourcePriority: buildSourcePriority(strategy, required),
+        citation: buildCitationRequirement(strategy, analysis, required),
+        recency: buildRecency(analysis, strategy),
+        contradictionPolicy: selectContradictionPolicy(strategy, analysis),
+        noAnswerConditions: buildNoAnswerConditions(strategy, analysis),
+        directives: buildDirectives(strategy, required),
+        ragEvaluation: buildRagEvaluation(analysis, strategy),
+        untrustedContent: true,
+    };
+}

package/dist/prompt-enhancer-safety.d.ts

@@ -0,0 +1,66 @@
+import { PROMPT_ENHANCER_SCHEMA_VERSION, type EnhancedPrompt, type EnhancedPromptId, type PromptTaskAnalysis } from "./prompt-enhancer.js";
+import type { PromptEnhancerValidation } from "./prompt-enhancer-validation.js";
+export type PromptSafetyRuleId = "trusted-untrusted-separation" | "untrusted-content-marked" | "no-authority-grant" | "no-secret-or-system-prompt-disclosure" | "human-review-for-risky-actions" | "least-privilege-tool-access" | "output-validation-required" | "no-manipulative-or-injected-instructions";
+export declare const PROMPT_SAFETY_RULE_IDS: readonly PromptSafetyRuleId[];
+export type PromptSafetyViolationCode = "missing-channel-separation" | "missing-untrusted-marker" | "missing-authority-restriction" | "missing-secrecy-rule" | "missing-human-review" | "missing-least-privilege" | "missing-output-validation" | "capability-grant-claim" | "secret-request" | "system-prompt-disclosure" | "untrusted-instruction-override" | "manipulative-instruction" | "hidden-assumption";
+export declare const PROMPT_SAFETY_VIOLATION_CODES: readonly PromptSafetyViolationCode[];
+export declare const isPromptSafetyViolationCode: (value: unknown) => value is PromptSafetyViolationCode;
+export type PromptSafetySeverity = "info" | "warning" | "blocking";
+export declare const PROMPT_SAFETY_SEVERITIES: readonly PromptSafetySeverity[];
+export type LeastPrivilegeConstraint = "no-tool-execution" | "no-file-write" | "no-network-egress" | "no-secret-access" | "require-human-approval";
+export declare const LEAST_PRIVILEGE_CONSTRAINTS: readonly LeastPrivilegeConstraint[];
+export type PromptSafetyDecision = "accepted" | "requires-human-review" | "rejected";
+export declare const PROMPT_SAFETY_DECISIONS: readonly PromptSafetyDecision[];
+export type PromptSafetyVerificationStatus = "passed" | "passed-with-review" | "failed";
+export declare const PROMPT_SAFETY_VERIFICATION_STATUSES: readonly PromptSafetyVerificationStatus[];
+export interface PromptSafetyFinding {
+    readonly code: PromptSafetyViolationCode;
+    readonly ruleId: PromptSafetyRuleId;
+    readonly severity: PromptSafetySeverity;
+    readonly detail: string;
+}
+export interface PromptSafetyAssessment {
+    readonly schemaVersion: typeof PROMPT_ENHANCER_SCHEMA_VERSION;
+    readonly promptId: EnhancedPromptId;
+    readonly decision: PromptSafetyDecision;
+    readonly requiresHumanReview: boolean;
+    readonly verificationStatus: PromptSafetyVerificationStatus;
+    readonly findings: readonly PromptSafetyFinding[];
+    readonly leastPrivilege: readonly LeastPrivilegeConstraint[];
+}
+export declare const PROMPT_SAFETY_VIOLATION_DETAILS: Readonly<Record<PromptSafetyViolationCode, string>>;
+/**
+ * Derive whether a task is risky enough to require human review before any side-effecting action
+ * (AC5). Pure. A task is risky when it is agentic, requests tool/egress authority, or is critical.
+ */
+export declare function requiresHumanReviewForAnalysis(analysis: PromptTaskAnalysis): boolean;
+/**
+ * Reduce a finding set and the human-review flag to the decision + verification status. Pure. Shared
+ * by the structural assessor and the gateway validate stage (which adds security findings first).
+ */
+export declare function summarizePromptSafety(findings: readonly PromptSafetyFinding[], requiresHumanReview: boolean): {
+    readonly decision: PromptSafetyDecision;
+    readonly verificationStatus: PromptSafetyVerificationStatus;
+};
+/**
+ * Compute the least-privilege constraint set for a task. Pure. Always denies tool/file/egress/secret
+ * authority (least privilege by default); risky tasks additionally require human approval (AC5).
+ */
+export declare function leastPrivilegeForAnalysis(analysis: PromptTaskAnalysis): readonly LeastPrivilegeConstraint[];
+/**
+ * Deterministically assess the STRUCTURAL safety of an `EnhancedPrompt` against the validate-stage
+ * rule set. Pure. Confirms the required safeguards are present (AC1/AC2/AC5, no-authority,
+ * no-disclosure, output validation) and that the trusted sections carry no authority-grant, override,
+ * or disclosure claim (AC3 defense in depth). The authoritative text-level detection over untrusted
+ * input is layered on top by the gateway validate stage; this function never inspects raw input.
+ */
+export declare function assessEnhancedPromptStructuralSafety(prompt: EnhancedPrompt, analysis: PromptTaskAnalysis): PromptSafetyAssessment;
+/**
+ * Validate a `PromptSafetyAssessment`. Pure; returns a discriminated result and never throws. Checks
+ * structural well-formedness and the cross-field invariants that make the assessment trustworthy: the
+ * verification status matches the decision, a `rejected` decision carries at least one blocking
+ * finding, and a human-review requirement implies the `require-human-approval` least-privilege
+ * constraint.
+ */
+export declare function validatePromptSafetyAssessment(input: unknown): PromptEnhancerValidation<PromptSafetyAssessment>;
+//# sourceMappingURL=prompt-enhancer-safety.d.ts.map