@harness-engineering/intelligence 0.3.0 → 0.4.0

package/dist/index.d.mts

@@ -741,7 +741,7 @@ declare const OUTCOME_EVAL_SYSTEM_PROMPT = "You are a post-execution outcome jud
  * a 4-backtick fence so a triple-backtick sequence inside the diff cannot close
  * the fence early.
  */
-declare function buildUserPrompt(section: string, diff: string, testOutput: string): string;
+declare function buildUserPrompt$1(section: string, diff: string, testOutput: string): string;
 
 /**
  * Result of resolving the judgment section from a spec's markdown.
@@ -828,6 +828,171 @@ declare class OutcomeEvaluator {
     private persistOutcome;
 }
 
+/**
+ * acceptance-eval contract types — the upstream twin of outcome-eval.
+ *
+ * `authority` is DERIVED in TypeScript from (measurability, confidence) via
+ * `deriveAcceptanceAuthority` in `./authority.js`. It is NEVER read from the
+ * LLM response — see `acceptanceVerdictSchema` in `./prompts.js`, which omits
+ * it. `Confidence`, `JudgedAgainst`, and `Authority` are REUSED from the
+ * outcome-eval module — not forked — consistent with the imported section-resolver.
+ */
+
+/** (c) the measurability gate dimension. */
+type Measurability = 'MEASURABLE' | 'NOT_MEASURABLE' | 'INCONCLUSIVE';
+/** A single advisory observation about one criterion or behavior. */
+interface Finding {
+    /** The specific criterion or user-visible behavior this finding references. */
+    target: string;
+    /** The advisory observation (e.g. 'not observable', 'no covering test'). */
+    message: string;
+}
+interface AcceptanceEvalInput {
+    /** Absolute or repo-relative path to the spec markdown. */
+    specPath: string;
+    /** Pre-resolved judgment section; otherwise the section-resolver runs. */
+    specSection?: string;
+    /**
+     * Located test snippets for coverage responsibility (b). Optional: absence
+     * degrades (b) coverageFindings to advisory-empty and never affects the
+     * (c) measurability gate.
+     */
+    testContent?: string;
+}
+interface AcceptanceVerdict {
+    measurability: Measurability;
+    confidence: Confidence;
+    /** DERIVED in TS from (measurability, confidence); never from the LLM. */
+    authority: Authority;
+    /** Which spec section resolved. */
+    judgedAgainst: JudgedAgainst;
+    /** (a) advisory — observability / testability / completeness critique. */
+    criteriaFindings: Finding[];
+    /** (b) advisory — user-visible behaviors with no covering test. */
+    coverageFindings: Finding[];
+    rationale: string;
+}
+
+/**
+ * Pure mapping from (measurability, confidence) to gate authority.
+ *
+ * Blocking iff a spec is judged NOT_MEASURABLE with high confidence — i.e. it
+ * objectively lacks measurable success criteria; every other combination,
+ * including all INCONCLUSIVE and MEASURABLE cases, is advisory. Missing or
+ * uncertain inputs never punish the spec.
+ *
+ * This function is the false-positive-critical seam. Authority is computed
+ * here in TypeScript and is NEVER trusted from the LLM response.
+ */
+declare function deriveAcceptanceAuthority(measurability: Measurability, confidence: Confidence): Authority;
+
+/** A single advisory finding. `.strict()` rejects unexpected keys. */
+declare const findingSchema: z.ZodObject<{
+    target: z.ZodString;
+    message: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    target: string;
+}, {
+    message: string;
+    target: string;
+}>;
+/**
+ * Zod schema for the LLM verdict response.
+ *
+ * `authority` is intentionally ABSENT: it is derived in TypeScript by
+ * `deriveAcceptanceAuthority` and must never be supplied by the model. The
+ * schema is `.strict()`, so an injected `authority` (or any other extra key)
+ * is rejected at the parse boundary rather than silently passing through.
+ */
+declare const acceptanceVerdictSchema: z.ZodObject<{
+    measurability: z.ZodEnum<["MEASURABLE", "NOT_MEASURABLE", "INCONCLUSIVE"]>;
+    confidence: z.ZodEnum<["low", "medium", "high"]>;
+    rationale: z.ZodString;
+    criteriaFindings: z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        target: string;
+    }, {
+        message: string;
+        target: string;
+    }>, "many">;
+    coverageFindings: z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        target: string;
+    }, {
+        message: string;
+        target: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    confidence: "low" | "medium" | "high";
+    rationale: string;
+    measurability: "INCONCLUSIVE" | "MEASURABLE" | "NOT_MEASURABLE";
+    criteriaFindings: {
+        message: string;
+        target: string;
+    }[];
+    coverageFindings: {
+        message: string;
+        target: string;
+    }[];
+}, {
+    confidence: "low" | "medium" | "high";
+    rationale: string;
+    measurability: "INCONCLUSIVE" | "MEASURABLE" | "NOT_MEASURABLE";
+    criteriaFindings: {
+        message: string;
+        target: string;
+    }[];
+    coverageFindings: {
+        message: string;
+        target: string;
+    }[];
+}>;
+type LlmAcceptanceVerdict = z.infer<typeof acceptanceVerdictSchema>;
+/**
+ * System prompt for acceptance-eval. Conservative-confidence posture mirrors
+ * outcome-eval: default to medium; high requires naming a specific criterion;
+ * bias toward advisory. `authority` is derived in TypeScript and must never be
+ * supplied by the model — the schema is `.strict()` and rejects it.
+ */
+declare const ACCEPTANCE_EVAL_SYSTEM_PROMPT = "You are a PRE-execution acceptance-criteria judge. Given a spec acceptance section (and optionally located test snippets), assess three things:\n(a) criteria quality \u2014 are the success criteria observable, testable, and complete? (advisory findings)\n(b) coverage \u2014 do any user-visible behaviors lack a covering test? (advisory findings)\n(c) measurability \u2014 does the spec state MEASURABLE, NOT_MEASURABLE, or is it INCONCLUSIVE on whether any measurable success criteria exist at all?\n\nConfidence calibration (be conservative \u2014 false alarms are costly):\n- Default to \"medium\" confidence.\n- Use \"high\" ONLY when you can name a SPECIFIC criterion (or its absence) and quote or paraphrase it in the rationale.\n- Use \"low\" when the section is ambiguous, partial, or insufficient to judge.\n- Bias toward advisory caution: if unsure between two confidence levels, choose the lower one.\n\nRules:\n- \"measurability\" is NOT_MEASURABLE only when the section states no observable, testable success criterion at all.\n- \"criteriaFindings\" holds advisory (a) observations; \"coverageFindings\" holds advisory (b) observations; both may be empty.\n- Do NOT emit an \"authority\" field. Authority is computed downstream in TypeScript from (measurability, confidence) and must never come from you.\n\nReturn your judgment using the structured_output tool.";
+/**
+ * Build the user prompt from the resolved spec section body and optional
+ * located test snippets. Test content is clamped to PROMPT_FIELD_MAX_CHARS and
+ * wrapped in a 4-backtick fence so an inner ``` cannot close the fence early.
+ */
+declare function buildUserPrompt(section: string, testContent?: string): string;
+
+interface AcceptanceEvaluatorOptions {
+    /** Override model for the acceptance-eval LLM call. */
+    model?: string;
+}
+/**
+ * Pre-execution acceptance-criteria judge — the upstream twin of
+ * OutcomeEvaluator. Built on the cli AnalysisProvider. The LLM returns only
+ * measurability/confidence/criteriaFindings/coverageFindings/rationale;
+ * `authority` is derived in TypeScript and never read from the model.
+ *
+ * Unlike OutcomeEvaluator it holds no GraphStore: there is no acceptance
+ * outcome node type and Phase 1 does not persist (see plan D-P1-3).
+ */
+declare class AcceptanceEvaluator {
+    private readonly provider;
+    private readonly options;
+    constructor(provider: AnalysisProvider, options?: AcceptanceEvaluatorOptions);
+    evaluate(input: AcceptanceEvalInput): Promise<AcceptanceVerdict>;
+    private judge;
+    private degradedVerdict;
+    private resolveJudgmentSection;
+    private buildVerdict;
+}
+
 /**
  * Compute historical complexity from past execution outcomes in the graph.
  *
@@ -1168,4 +1333,4 @@ declare function saveProfiles(projectRoot: string, store: ProfileStore): void;
  */
 declare function refreshProfiles(projectRoot: string, graphStore: GraphStore, opts?: Omit<SpecializationOptions, 'persona'>): ProfileStore;
 
-export { type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmVerdict, type ManualInput, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, buildSpecializationProfile, buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAuthority, detectBlindSpots, enrich, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };
+export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };

package/dist/index.d.ts

@@ -741,7 +741,7 @@ declare const OUTCOME_EVAL_SYSTEM_PROMPT = "You are a post-execution outcome jud
  * a 4-backtick fence so a triple-backtick sequence inside the diff cannot close
  * the fence early.
  */
-declare function buildUserPrompt(section: string, diff: string, testOutput: string): string;
+declare function buildUserPrompt$1(section: string, diff: string, testOutput: string): string;
 
 /**
  * Result of resolving the judgment section from a spec's markdown.
@@ -828,6 +828,171 @@ declare class OutcomeEvaluator {
     private persistOutcome;
 }
 
+/**
+ * acceptance-eval contract types — the upstream twin of outcome-eval.
+ *
+ * `authority` is DERIVED in TypeScript from (measurability, confidence) via
+ * `deriveAcceptanceAuthority` in `./authority.js`. It is NEVER read from the
+ * LLM response — see `acceptanceVerdictSchema` in `./prompts.js`, which omits
+ * it. `Confidence`, `JudgedAgainst`, and `Authority` are REUSED from the
+ * outcome-eval module — not forked — consistent with the imported section-resolver.
+ */
+
+/** (c) the measurability gate dimension. */
+type Measurability = 'MEASURABLE' | 'NOT_MEASURABLE' | 'INCONCLUSIVE';
+/** A single advisory observation about one criterion or behavior. */
+interface Finding {
+    /** The specific criterion or user-visible behavior this finding references. */
+    target: string;
+    /** The advisory observation (e.g. 'not observable', 'no covering test'). */
+    message: string;
+}
+interface AcceptanceEvalInput {
+    /** Absolute or repo-relative path to the spec markdown. */
+    specPath: string;
+    /** Pre-resolved judgment section; otherwise the section-resolver runs. */
+    specSection?: string;
+    /**
+     * Located test snippets for coverage responsibility (b). Optional: absence
+     * degrades (b) coverageFindings to advisory-empty and never affects the
+     * (c) measurability gate.
+     */
+    testContent?: string;
+}
+interface AcceptanceVerdict {
+    measurability: Measurability;
+    confidence: Confidence;
+    /** DERIVED in TS from (measurability, confidence); never from the LLM. */
+    authority: Authority;
+    /** Which spec section resolved. */
+    judgedAgainst: JudgedAgainst;
+    /** (a) advisory — observability / testability / completeness critique. */
+    criteriaFindings: Finding[];
+    /** (b) advisory — user-visible behaviors with no covering test. */
+    coverageFindings: Finding[];
+    rationale: string;
+}
+
+/**
+ * Pure mapping from (measurability, confidence) to gate authority.
+ *
+ * Blocking iff a spec is judged NOT_MEASURABLE with high confidence — i.e. it
+ * objectively lacks measurable success criteria; every other combination,
+ * including all INCONCLUSIVE and MEASURABLE cases, is advisory. Missing or
+ * uncertain inputs never punish the spec.
+ *
+ * This function is the false-positive-critical seam. Authority is computed
+ * here in TypeScript and is NEVER trusted from the LLM response.
+ */
+declare function deriveAcceptanceAuthority(measurability: Measurability, confidence: Confidence): Authority;
+
+/** A single advisory finding. `.strict()` rejects unexpected keys. */
+declare const findingSchema: z.ZodObject<{
+    target: z.ZodString;
+    message: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    target: string;
+}, {
+    message: string;
+    target: string;
+}>;
+/**
+ * Zod schema for the LLM verdict response.
+ *
+ * `authority` is intentionally ABSENT: it is derived in TypeScript by
+ * `deriveAcceptanceAuthority` and must never be supplied by the model. The
+ * schema is `.strict()`, so an injected `authority` (or any other extra key)
+ * is rejected at the parse boundary rather than silently passing through.
+ */
+declare const acceptanceVerdictSchema: z.ZodObject<{
+    measurability: z.ZodEnum<["MEASURABLE", "NOT_MEASURABLE", "INCONCLUSIVE"]>;
+    confidence: z.ZodEnum<["low", "medium", "high"]>;
+    rationale: z.ZodString;
+    criteriaFindings: z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        target: string;
+    }, {
+        message: string;
+        target: string;
+    }>, "many">;
+    coverageFindings: z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        message: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        target: string;
+    }, {
+        message: string;
+        target: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    confidence: "low" | "medium" | "high";
+    rationale: string;
+    measurability: "INCONCLUSIVE" | "MEASURABLE" | "NOT_MEASURABLE";
+    criteriaFindings: {
+        message: string;
+        target: string;
+    }[];
+    coverageFindings: {
+        message: string;
+        target: string;
+    }[];
+}, {
+    confidence: "low" | "medium" | "high";
+    rationale: string;
+    measurability: "INCONCLUSIVE" | "MEASURABLE" | "NOT_MEASURABLE";
+    criteriaFindings: {
+        message: string;
+        target: string;
+    }[];
+    coverageFindings: {
+        message: string;
+        target: string;
+    }[];
+}>;
+type LlmAcceptanceVerdict = z.infer<typeof acceptanceVerdictSchema>;
+/**
+ * System prompt for acceptance-eval. Conservative-confidence posture mirrors
+ * outcome-eval: default to medium; high requires naming a specific criterion;
+ * bias toward advisory. `authority` is derived in TypeScript and must never be
+ * supplied by the model — the schema is `.strict()` and rejects it.
+ */
+declare const ACCEPTANCE_EVAL_SYSTEM_PROMPT = "You are a PRE-execution acceptance-criteria judge. Given a spec acceptance section (and optionally located test snippets), assess three things:\n(a) criteria quality \u2014 are the success criteria observable, testable, and complete? (advisory findings)\n(b) coverage \u2014 do any user-visible behaviors lack a covering test? (advisory findings)\n(c) measurability \u2014 does the spec state MEASURABLE, NOT_MEASURABLE, or is it INCONCLUSIVE on whether any measurable success criteria exist at all?\n\nConfidence calibration (be conservative \u2014 false alarms are costly):\n- Default to \"medium\" confidence.\n- Use \"high\" ONLY when you can name a SPECIFIC criterion (or its absence) and quote or paraphrase it in the rationale.\n- Use \"low\" when the section is ambiguous, partial, or insufficient to judge.\n- Bias toward advisory caution: if unsure between two confidence levels, choose the lower one.\n\nRules:\n- \"measurability\" is NOT_MEASURABLE only when the section states no observable, testable success criterion at all.\n- \"criteriaFindings\" holds advisory (a) observations; \"coverageFindings\" holds advisory (b) observations; both may be empty.\n- Do NOT emit an \"authority\" field. Authority is computed downstream in TypeScript from (measurability, confidence) and must never come from you.\n\nReturn your judgment using the structured_output tool.";
+/**
+ * Build the user prompt from the resolved spec section body and optional
+ * located test snippets. Test content is clamped to PROMPT_FIELD_MAX_CHARS and
+ * wrapped in a 4-backtick fence so an inner ``` cannot close the fence early.
+ */
+declare function buildUserPrompt(section: string, testContent?: string): string;
+
+interface AcceptanceEvaluatorOptions {
+    /** Override model for the acceptance-eval LLM call. */
+    model?: string;
+}
+/**
+ * Pre-execution acceptance-criteria judge — the upstream twin of
+ * OutcomeEvaluator. Built on the cli AnalysisProvider. The LLM returns only
+ * measurability/confidence/criteriaFindings/coverageFindings/rationale;
+ * `authority` is derived in TypeScript and never read from the model.
+ *
+ * Unlike OutcomeEvaluator it holds no GraphStore: there is no acceptance
+ * outcome node type and Phase 1 does not persist (see plan D-P1-3).
+ */
+declare class AcceptanceEvaluator {
+    private readonly provider;
+    private readonly options;
+    constructor(provider: AnalysisProvider, options?: AcceptanceEvaluatorOptions);
+    evaluate(input: AcceptanceEvalInput): Promise<AcceptanceVerdict>;
+    private judge;
+    private degradedVerdict;
+    private resolveJudgmentSection;
+    private buildVerdict;
+}
+
 /**
  * Compute historical complexity from past execution outcomes in the graph.
  *
@@ -1168,4 +1333,4 @@ declare function saveProfiles(projectRoot: string, store: ProfileStore): void;
  */
 declare function refreshProfiles(projectRoot: string, graphStore: GraphStore, opts?: Omit<SpecializationOptions, 'persona'>): ProfileStore;
 
-export { type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmVerdict, type ManualInput, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, buildSpecializationProfile, buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAuthority, detectBlindSpots, enrich, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };
+export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };

package/dist/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ACCEPTANCE_EVAL_SYSTEM_PROMPT: () => ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+  AcceptanceEvaluator: () => AcceptanceEvaluator,
   AnthropicAnalysisProvider: () => AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider: () => ClaudeCliAnalysisProvider,
   ExecutionOutcomeConnector: () => ExecutionOutcomeConnector,
@@ -39,6 +41,8 @@ __export(index_exports, {
   OpenAICompatibleAnalysisProvider: () => OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator: () => OutcomeEvaluator,
   PeslSimulator: () => PeslSimulator,
+  acceptanceVerdictSchema: () => acceptanceVerdictSchema,
+  buildAcceptanceUserPrompt: () => buildUserPrompt3,
   buildSpecializationProfile: () => buildSpecializationProfile,
   buildUserPrompt: () => buildUserPrompt2,
   computeExpertiseLevel: () => computeExpertiseLevel,
@@ -49,9 +53,11 @@ __export(index_exports, {
   computeStructuralComplexity: () => computeStructuralComplexity,
   createCanaryAdapter: () => createCanaryAdapter,
   decayWeight: () => decayWeight,
+  deriveAcceptanceAuthority: () => deriveAcceptanceAuthority,
   deriveAuthority: () => deriveAuthority,
   detectBlindSpots: () => detectBlindSpots,
   enrich: () => enrich,
+  findingSchema: () => findingSchema,
   githubToRawWorkItem: () => githubToRawWorkItem,
   jiraToRawWorkItem: () => jiraToRawWorkItem,
   linearToRawWorkItem: () => linearToRawWorkItem,
@@ -1497,6 +1503,145 @@ var OutcomeEvaluator = class {
   }
 };
 
+// src/acceptance-eval/authority.ts
+function deriveAcceptanceAuthority(measurability, confidence) {
+  return measurability === "NOT_MEASURABLE" && confidence === "high" ? "blocking" : "advisory";
+}
+
+// src/acceptance-eval/prompts.ts
+var import_zod5 = require("zod");
+var findingSchema = import_zod5.z.object({
+  target: import_zod5.z.string().describe("The criterion or user-visible behavior referenced"),
+  message: import_zod5.z.string().describe("The advisory observation")
+}).strict();
+var acceptanceVerdictSchema = import_zod5.z.object({
+  measurability: import_zod5.z.enum(["MEASURABLE", "NOT_MEASURABLE", "INCONCLUSIVE"]).describe("Whether the spec section states measurable, testable success criteria"),
+  confidence: import_zod5.z.enum(["low", "medium", "high"]).describe("Confidence in the verdict; high requires a named criterion"),
+  rationale: import_zod5.z.string().describe("Cites specific criteria/behaviors"),
+  criteriaFindings: import_zod5.z.array(findingSchema).describe("(a) advisory observability/testability/completeness critique"),
+  coverageFindings: import_zod5.z.array(findingSchema).describe("(b) advisory user-visible behaviors with no covering test")
+}).strict();
+var ACCEPTANCE_EVAL_SYSTEM_PROMPT = `You are a PRE-execution acceptance-criteria judge. Given a spec acceptance section (and optionally located test snippets), assess three things:
+(a) criteria quality \u2014 are the success criteria observable, testable, and complete? (advisory findings)
+(b) coverage \u2014 do any user-visible behaviors lack a covering test? (advisory findings)
+(c) measurability \u2014 does the spec state MEASURABLE, NOT_MEASURABLE, or is it INCONCLUSIVE on whether any measurable success criteria exist at all?
+
+Confidence calibration (be conservative \u2014 false alarms are costly):
+- Default to "medium" confidence.
+- Use "high" ONLY when you can name a SPECIFIC criterion (or its absence) and quote or paraphrase it in the rationale.
+- Use "low" when the section is ambiguous, partial, or insufficient to judge.
+- Bias toward advisory caution: if unsure between two confidence levels, choose the lower one.
+
+Rules:
+- "measurability" is NOT_MEASURABLE only when the section states no observable, testable success criterion at all.
+- "criteriaFindings" holds advisory (a) observations; "coverageFindings" holds advisory (b) observations; both may be empty.
+- Do NOT emit an "authority" field. Authority is computed downstream in TypeScript from (measurability, confidence) and must never come from you.
+
+Return your judgment using the structured_output tool.`;
+var PROMPT_FIELD_MAX_CHARS2 = 12e3;
+var FENCE2 = "````";
+function clampField2(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= PROMPT_FIELD_MAX_CHARS2) return trimmed;
+  const dropped = trimmed.length - PROMPT_FIELD_MAX_CHARS2;
+  return `${trimmed.slice(0, PROMPT_FIELD_MAX_CHARS2)}
+\u2026 [truncated ${dropped} chars]`;
+}
+function buildUserPrompt3(section, testContent) {
+  const tests = (testContent ?? "").trim();
+  return [
+    "## Spec Acceptance Criteria (judge against this section)",
+    section.trim() || "(empty \u2014 treat as inconclusive)",
+    "",
+    "## Located Test Snippets (coverage evidence \u2014 may be absent)",
+    `${FENCE2}`,
+    tests ? clampField2(tests) : "(no test content provided)",
+    FENCE2,
+    "",
+    "## Instructions",
+    "Judge measurability (c), and emit advisory criteria (a) and coverage (b) findings. Calibrate confidence conservatively per your system instructions. Cite specific criteria in the rationale."
+  ].join("\n");
+}
+
+// src/acceptance-eval/evaluator.ts
+var import_promises2 = require("fs/promises");
+var AcceptanceEvaluator = class {
+  provider;
+  options;
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.options = options;
+  }
+  async evaluate(input) {
+    let resolved;
+    try {
+      resolved = await this.resolveJudgmentSection(input);
+    } catch {
+      return this.degradedVerdict("overview");
+    }
+    if (resolved === null) {
+      return this.buildVerdict(
+        "INCONCLUSIVE",
+        "low",
+        "No judgable spec section found.",
+        "overview",
+        [],
+        []
+      );
+    }
+    return this.judge(resolved, input);
+  }
+  async judge(resolved, input) {
+    try {
+      const response = await this.provider.analyze({
+        prompt: buildUserPrompt3(resolved.body, input.testContent),
+        systemPrompt: ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+        responseSchema: acceptanceVerdictSchema,
+        ...this.options.model !== void 0 && { model: this.options.model }
+      });
+      const llm = acceptanceVerdictSchema.parse(response.result);
+      return this.buildVerdict(
+        llm.measurability,
+        llm.confidence,
+        llm.rationale,
+        resolved.judgedAgainst,
+        llm.criteriaFindings,
+        llm.coverageFindings
+      );
+    } catch {
+      return this.degradedVerdict(resolved.judgedAgainst);
+    }
+  }
+  degradedVerdict(judgedAgainst) {
+    return this.buildVerdict(
+      "INCONCLUSIVE",
+      "low",
+      "Evaluation could not be completed; defaulting to an inconclusive, advisory verdict.",
+      judgedAgainst,
+      [],
+      []
+    );
+  }
+  async resolveJudgmentSection(input) {
+    if (input.specSection !== void 0) {
+      return input.specSection.trim() === "" ? null : { judgedAgainst: "success-criteria", body: input.specSection };
+    }
+    const markdown = await (0, import_promises2.readFile)(input.specPath, "utf8");
+    return resolveSection(markdown);
+  }
+  buildVerdict(measurability, confidence, rationale, judgedAgainst, criteriaFindings, coverageFindings) {
+    return {
+      measurability,
+      confidence,
+      rationale,
+      judgedAgainst,
+      criteriaFindings,
+      coverageFindings,
+      authority: deriveAcceptanceAuthority(measurability, confidence)
+    };
+  }
+};
+
 // src/pipeline.ts
 var IntelligencePipeline = class {
   provider;
@@ -1969,6 +2114,8 @@ function refreshProfiles(projectRoot, graphStore, opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+  AcceptanceEvaluator,
   AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider,
   ExecutionOutcomeConnector,
@@ -1978,6 +2125,8 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator,
   PeslSimulator,
+  acceptanceVerdictSchema,
+  buildAcceptanceUserPrompt,
   buildSpecializationProfile,
   buildUserPrompt,
   computeExpertiseLevel,
@@ -1988,9 +2137,11 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   computeStructuralComplexity,
   createCanaryAdapter,
   decayWeight,
+  deriveAcceptanceAuthority,
   deriveAuthority,
   detectBlindSpots,
   enrich,
+  findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
   linearToRawWorkItem,

package/dist/index.mjs

@@ -1423,6 +1423,145 @@ var OutcomeEvaluator = class {
   }
 };
 
+// src/acceptance-eval/authority.ts
+function deriveAcceptanceAuthority(measurability, confidence) {
+  return measurability === "NOT_MEASURABLE" && confidence === "high" ? "blocking" : "advisory";
+}
+
+// src/acceptance-eval/prompts.ts
+import { z as z5 } from "zod";
+var findingSchema = z5.object({
+  target: z5.string().describe("The criterion or user-visible behavior referenced"),
+  message: z5.string().describe("The advisory observation")
+}).strict();
+var acceptanceVerdictSchema = z5.object({
+  measurability: z5.enum(["MEASURABLE", "NOT_MEASURABLE", "INCONCLUSIVE"]).describe("Whether the spec section states measurable, testable success criteria"),
+  confidence: z5.enum(["low", "medium", "high"]).describe("Confidence in the verdict; high requires a named criterion"),
+  rationale: z5.string().describe("Cites specific criteria/behaviors"),
+  criteriaFindings: z5.array(findingSchema).describe("(a) advisory observability/testability/completeness critique"),
+  coverageFindings: z5.array(findingSchema).describe("(b) advisory user-visible behaviors with no covering test")
+}).strict();
+var ACCEPTANCE_EVAL_SYSTEM_PROMPT = `You are a PRE-execution acceptance-criteria judge. Given a spec acceptance section (and optionally located test snippets), assess three things:
+(a) criteria quality \u2014 are the success criteria observable, testable, and complete? (advisory findings)
+(b) coverage \u2014 do any user-visible behaviors lack a covering test? (advisory findings)
+(c) measurability \u2014 does the spec state MEASURABLE, NOT_MEASURABLE, or is it INCONCLUSIVE on whether any measurable success criteria exist at all?
+
+Confidence calibration (be conservative \u2014 false alarms are costly):
+- Default to "medium" confidence.
+- Use "high" ONLY when you can name a SPECIFIC criterion (or its absence) and quote or paraphrase it in the rationale.
+- Use "low" when the section is ambiguous, partial, or insufficient to judge.
+- Bias toward advisory caution: if unsure between two confidence levels, choose the lower one.
+
+Rules:
+- "measurability" is NOT_MEASURABLE only when the section states no observable, testable success criterion at all.
+- "criteriaFindings" holds advisory (a) observations; "coverageFindings" holds advisory (b) observations; both may be empty.
+- Do NOT emit an "authority" field. Authority is computed downstream in TypeScript from (measurability, confidence) and must never come from you.
+
+Return your judgment using the structured_output tool.`;
+var PROMPT_FIELD_MAX_CHARS2 = 12e3;
+var FENCE2 = "````";
+function clampField2(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= PROMPT_FIELD_MAX_CHARS2) return trimmed;
+  const dropped = trimmed.length - PROMPT_FIELD_MAX_CHARS2;
+  return `${trimmed.slice(0, PROMPT_FIELD_MAX_CHARS2)}
+\u2026 [truncated ${dropped} chars]`;
+}
+function buildUserPrompt3(section, testContent) {
+  const tests = (testContent ?? "").trim();
+  return [
+    "## Spec Acceptance Criteria (judge against this section)",
+    section.trim() || "(empty \u2014 treat as inconclusive)",
+    "",
+    "## Located Test Snippets (coverage evidence \u2014 may be absent)",
+    `${FENCE2}`,
+    tests ? clampField2(tests) : "(no test content provided)",
+    FENCE2,
+    "",
+    "## Instructions",
+    "Judge measurability (c), and emit advisory criteria (a) and coverage (b) findings. Calibrate confidence conservatively per your system instructions. Cite specific criteria in the rationale."
+  ].join("\n");
+}
+
+// src/acceptance-eval/evaluator.ts
+import { readFile as readFile2 } from "fs/promises";
+var AcceptanceEvaluator = class {
+  provider;
+  options;
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.options = options;
+  }
+  async evaluate(input) {
+    let resolved;
+    try {
+      resolved = await this.resolveJudgmentSection(input);
+    } catch {
+      return this.degradedVerdict("overview");
+    }
+    if (resolved === null) {
+      return this.buildVerdict(
+        "INCONCLUSIVE",
+        "low",
+        "No judgable spec section found.",
+        "overview",
+        [],
+        []
+      );
+    }
+    return this.judge(resolved, input);
+  }
+  async judge(resolved, input) {
+    try {
+      const response = await this.provider.analyze({
+        prompt: buildUserPrompt3(resolved.body, input.testContent),
+        systemPrompt: ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+        responseSchema: acceptanceVerdictSchema,
+        ...this.options.model !== void 0 && { model: this.options.model }
+      });
+      const llm = acceptanceVerdictSchema.parse(response.result);
+      return this.buildVerdict(
+        llm.measurability,
+        llm.confidence,
+        llm.rationale,
+        resolved.judgedAgainst,
+        llm.criteriaFindings,
+        llm.coverageFindings
+      );
+    } catch {
+      return this.degradedVerdict(resolved.judgedAgainst);
+    }
+  }
+  degradedVerdict(judgedAgainst) {
+    return this.buildVerdict(
+      "INCONCLUSIVE",
+      "low",
+      "Evaluation could not be completed; defaulting to an inconclusive, advisory verdict.",
+      judgedAgainst,
+      [],
+      []
+    );
+  }
+  async resolveJudgmentSection(input) {
+    if (input.specSection !== void 0) {
+      return input.specSection.trim() === "" ? null : { judgedAgainst: "success-criteria", body: input.specSection };
+    }
+    const markdown = await readFile2(input.specPath, "utf8");
+    return resolveSection(markdown);
+  }
+  buildVerdict(measurability, confidence, rationale, judgedAgainst, criteriaFindings, coverageFindings) {
+    return {
+      measurability,
+      confidence,
+      rationale,
+      judgedAgainst,
+      criteriaFindings,
+      coverageFindings,
+      authority: deriveAcceptanceAuthority(measurability, confidence)
+    };
+  }
+};
+
 // src/pipeline.ts
 var IntelligencePipeline = class {
   provider;
@@ -1894,6 +2033,8 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   return store;
 }
 export {
+  ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+  AcceptanceEvaluator,
   AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider,
   ExecutionOutcomeConnector,
@@ -1903,6 +2044,8 @@ export {
   OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator,
   PeslSimulator,
+  acceptanceVerdictSchema,
+  buildUserPrompt3 as buildAcceptanceUserPrompt,
   buildSpecializationProfile,
   buildUserPrompt2 as buildUserPrompt,
   computeExpertiseLevel,
@@ -1913,9 +2056,11 @@ export {
   computeStructuralComplexity,
   createCanaryAdapter,
   decayWeight,
+  deriveAcceptanceAuthority,
   deriveAuthority,
   detectBlindSpots,
   enrich,
+  findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
   linearToRawWorkItem,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/intelligence",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Intelligence pipeline for spec enrichment, complexity modeling, and pre-execution simulation",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,8 +40,8 @@
     "@anthropic-ai/sdk": "^0.95.1",
     "openai": "^6.0.0",
     "zod": "^3.25.76",
-    "@harness-engineering/graph": "0.11.0",
-    "@harness-engineering/types": "0.16.0"
+    "@harness-engineering/graph": "0.11.2",
+    "@harness-engineering/types": "0.16.2"
   },
   "optionalDependencies": {
     "canary-test-cli": "^5.4.0"