@oscharko-dev/keiko 0.2.0-beta.7 → 0.2.0-beta.9

package/node_modules/@oscharko-dev/keiko-workflows/dist/qualityIntelligence/modelRoutedTestDesign.js

@@ -6,10 +6,10 @@
 // is injected as an abstract `generate` port so this module stays free of provider SDKs and the
 // server tier owns the gateway wiring (ADR-0023 D5/D6).
 import { QualityIntelligence as QI } from "@oscharko-dev/keiko-contracts";
-import { buildAtomCoverageStatuses, buildCoverageMap, buildRequirementExcerpt, computeCandidateEquivalenceSignature, deduplicateCandidates, deriveIntent, designTestCaseCandidates, scoreFromDimensions, TEST_QUALITY_WEAK_THRESHOLD, validateCandidates, QualityIntelligenceGeneration, } from "@oscharko-dev/keiko-quality-intelligence";
+import { buildAtomCoverageStatuses, buildCoverageMap, buildRequirementExcerpt, computeCandidateEquivalenceSignature, deduplicateCandidates, deriveIntent, designTestCaseCandidates, scoreFromDimensions, TEST_QUALITY_WEAK_THRESHOLD, verdictFromDimensions, validateCandidates, QualityIntelligenceGeneration, } from "@oscharko-dev/keiko-quality-intelligence";
 import { sha256Hex } from "@oscharko-dev/keiko-security";
 import { QI_TEST_DESIGN_WORKFLOW_DESCRIPTOR } from "./descriptors.js";
-import { emit, emitCandidateProposed, emitFindingsRecorded, emitQueuedAndStarted, finaliseFailureOrCancellation, makeContext, persistRun, StageCancelledError, toCoverageMatrixRows, truncateCandidates, truncateFindings, withStage, } from "./runtimeCommon.js";
+import { emit, emitCandidateProposed, emitFindingsRecorded, emitQueuedAndStarted, finaliseFailureOrCancellation, makeContext, persistRun, safeReasonSummary, StageCancelledError, toCoverageMatrixRows, truncateCandidates, truncateFindings, withStage, } from "./runtimeCommon.js";
 import { isCancelled } from "./cancellation.js";
 class EmptyEvidenceError extends Error {
     constructor() {
@@ -71,8 +71,8 @@ function buildCoverageGapFinding(runId, atomStatus, ordinal, excerpt) {
         ? `Atom ${String(atomStatus.atomId)}`
         : `Atom ${String(atomStatus.atomId)} ("${excerpt}")`;
     const summary = atomStatus.status === "uncovered"
-        ? `${atomLabel} has no tracing test (uncovered).`
-        : `${atomLabel} is only weakly covered (no dedicated test traces to it).`;
+        ? `${atomLabel} hat keinen zugeordneten Test (uncovered).`
+        : `${atomLabel} ist nur schwach abgedeckt (kein dedizierter Test referenziert dieses Atom).`;
     return Object.freeze({
         kind: "coverage-gap",
         id: QI.asQualityIntelligenceValidationFindingId(idStr),
@@ -82,11 +82,20 @@ function buildCoverageGapFinding(runId, atomStatus, ordinal, excerpt) {
         evidenceAtomIds: Object.freeze([atomStatus.atomId]),
     });
 }
+const MODEL_DELTA_CANDIDATE_CEILING = 16;
+const MODEL_DELTA_CANDIDATE_FLOOR = 3;
+function modelDeltaCandidateLimit(evidenceCount, runLimit) {
+    const boundedRunLimit = Math.max(1, Math.trunc(runLimit));
+    const evidenceAwareLimit = Math.max(MODEL_DELTA_CANDIDATE_FLOOR, Math.max(1, Math.trunc(evidenceCount)) * 2);
+    return Math.max(1, Math.min(boundedRunLimit, MODEL_DELTA_CANDIDATE_CEILING, evidenceAwareLimit));
+}
 function deterministicBaselineCandidates(ctx, input) {
+    const atomTextById = new Map(input.ingestedAtoms.map((entry) => [String(entry.atom.id), entry.canonicalText]));
     const candidates = designTestCaseCandidates({
         runId: input.plan.id,
         intent: deriveIntent(input.envelopes, ctx.profile),
         atoms: input.ingestedAtoms.map((entry) => entry.atom),
+        atomTextById,
         profile: ctx.profile,
     });
     return truncateCandidates(deduplicateCandidates(candidates), ctx.limits.maxCandidatesPerRun);
@@ -136,10 +145,10 @@ function selectReviewCandidates(persisted, baseline, delta) {
     const persistedDelta = delta.filter((candidate) => persistedIds.has(String(candidate.id)));
     return persistedDelta.length > 0 ? Object.freeze(persistedDelta) : baseline;
 }
-function modelGenerationOutput(result, ctx, input, maxCandidates) {
+function modelGenerationOutput(result, ctx, input, runCandidateLimit, modelDeltaLimit) {
     const baseline = deterministicBaselineCandidates(ctx, input);
-    const delta = parseModelCandidates(result, ctx, input, maxCandidates);
-    const candidates = appendModelDelta(baseline, delta, maxCandidates);
+    const delta = parseModelCandidates(result, ctx, input, modelDeltaLimit);
+    const candidates = appendModelDelta(baseline, delta, runCandidateLimit);
     return {
         candidates,
         reviewCandidates: selectReviewCandidates(candidates, baseline, delta),
@@ -152,6 +161,25 @@ function modelGenerationOutput(result, ctx, input, maxCandidates) {
         modelParameters: result.modelParameters,
     };
 }
+function baselineFallbackGenerationOutput(ctx, input, reasonSummary) {
+    const candidates = deterministicBaselineCandidates(ctx, input);
+    return {
+        candidates,
+        reviewCandidates: candidates,
+        skipJudge: true,
+        fallbackReason: reasonSummary,
+        modelParameters: { generationFallbackReason: reasonSummary },
+    };
+}
+function hasQiCode(error, code) {
+    if (!(error instanceof Error))
+        return false;
+    const coded = error;
+    return typeof coded.code === "string" && coded.code === code;
+}
+function shouldCountRejectedGenerationDispatch(error) {
+    return !hasQiCode(error, "QI_PROMPT_TOO_LARGE");
+}
 async function generateCandidates(ctx, input, deps) {
     if (input.ingestedAtoms.length === 0) {
         throw new EmptyEvidenceError();
@@ -161,11 +189,12 @@ async function generateCandidates(ctx, input, deps) {
         kind: a.atom.kind,
         text: a.canonicalText,
     }));
-    const maxCandidates = ctx.limits.maxCandidatesPerRun;
+    const runCandidateLimit = ctx.limits.maxCandidatesPerRun;
+    const modelDeltaLimit = modelDeltaCandidateLimit(evidence.length, runCandidateLimit);
     const instruction = QualityIntelligenceGeneration.buildTestDesignInstruction({
         evidenceCount: evidence.length,
         profile: ctx.profile,
-        maxTestCases: maxCandidates,
+        maxTestCases: modelDeltaLimit,
     });
     // Count the generation gateway dispatch as an ATTEMPT, mirroring the judge contract
     // (judgeOneCandidate counts before its await). The generation port makes at most one gateway
@@ -174,37 +203,43 @@ async function generateCandidates(ctx, input, deps) {
     // under-reported a failed run's audit trail as 0 gateway calls (#273 audit; #843 undercount class).
     // The deterministic baseline port never rejects and reports modelCallCount 0, so it is unaffected.
     let result;
+    let countedGatewayDispatch = false;
     try {
         result = await deps.generate.generate({
             systemPrompt: QualityIntelligenceGeneration.QI_TEST_DESIGN_SYSTEM_PROMPT,
             instruction,
             evidence,
-            maxCandidates,
+            maxCandidates: modelDeltaLimit,
             signal: ctx.signal,
         });
+        ctx.modelGatewayCallCount += result.modelCallCount;
+        countedGatewayDispatch = result.modelCallCount > 0;
+        if (result.modelId === undefined && result.modelCallCount === 0) {
+            const candidates = deterministicBaselineCandidates(ctx, input);
+            return {
+                candidates,
+                reviewCandidates: candidates,
+                ...(result.seedUsed !== undefined ? { seedUsed: result.seedUsed } : {}),
+                modelParameters: result.modelParameters,
+            };
+        }
+        return modelGenerationOutput(result, ctx, input, runCandidateLimit, modelDeltaLimit);
     }
     catch (error) {
-        ctx.modelGatewayCallCount += 1;
-        throw error;
-    }
-    ctx.modelGatewayCallCount += result.modelCallCount;
-    if (result.modelId === undefined && result.modelCallCount === 0) {
-        const candidates = deterministicBaselineCandidates(ctx, input);
-        return {
-            candidates,
-            reviewCandidates: candidates,
-            ...(result.seedUsed !== undefined ? { seedUsed: result.seedUsed } : {}),
-            modelParameters: result.modelParameters,
-        };
+        if (isCancellationError(ctx, error))
+            throw new StageCancelledError();
+        if (!countedGatewayDispatch && shouldCountRejectedGenerationDispatch(error)) {
+            ctx.modelGatewayCallCount += 1;
+        }
+        return baselineFallbackGenerationOutput(ctx, input, safeReasonSummary(error));
     }
-    return modelGenerationOutput(result, ctx, input, maxCandidates);
 }
 function candidateSummaryText(candidate) {
     const parts = [
-        `Title: ${candidate.title}`,
-        `Preconditions: ${candidate.preconditions.join("; ")}`,
-        `Steps: ${candidate.steps.join("; ")}`,
-        `Expected: ${candidate.expectedResults.join("; ")}`,
+        `Titel: ${candidate.title}`,
+        `Vorbedingungen: ${candidate.preconditions.join("; ")}`,
+        `Schritte: ${candidate.steps.join("; ")}`,
+        `Erwartetes Ergebnis: ${candidate.expectedResults.join("; ")}`,
     ];
     return parts.join("\n");
 }
@@ -213,10 +248,10 @@ const FINDING_KIND_TRUNCATION_PRIORITY = {
     "test-quality": 0,
 };
 const JUDGE_DIMENSION_LABEL = {
-    verifiability: "Verifiability",
-    atomicity: "Atomicity",
-    determinism: "Determinism",
-    "ac-fidelity": "AC fidelity",
+    verifiability: "Prüfbarkeit",
+    atomicity: "Atomarität",
+    determinism: "Determinismus",
+    "ac-fidelity": "AC-Treue",
 };
 function sourceContextForCandidate(candidate, ingestedAtoms) {
     const byAtomId = new Map(ingestedAtoms.map((entry) => [
@@ -278,8 +313,8 @@ const JUDGE_CONCURRENCY = 4;
 function isCancellationError(ctx, error) {
     return error instanceof StageCancelledError || isCancelled(ctx.signal);
 }
-const JUDGE_ERROR_RATIONALE = "Quality judge could not evaluate this candidate; treating it as weak for audit.";
-const JUDGE_BUDGET_RATIONALE = "Quality judge budget exhausted before this candidate could be evaluated; treating it as weak for audit.";
+const JUDGE_ERROR_RATIONALE = "Der Quality-Judge konnte diesen Kandidaten nicht bewerten; er wird für das Audit als schwach behandelt.";
+const JUDGE_BUDGET_RATIONALE = "Das Quality-Judge-Budget war vor der Bewertung dieses Kandidaten ausgeschöpft; er wird für das Audit als schwach behandelt.";
 function buildSyntheticWeakJudgeOutcome(ctx, candidate, ordinal, rationale) {
     return {
         strong: false,
@@ -290,9 +325,10 @@ function buildSyntheticWeakJudgeOutcome(ctx, candidate, ordinal, rationale) {
 function cloneDimensions(dimensions) {
     return Object.freeze(dimensions.map((dimension) => Object.freeze({ ...dimension })));
 }
-function qualityVerdictFromJudge(verdict, score) {
+function qualityVerdictFromJudge(verdict) {
+    const score = scoreFromDimensions(verdict.dimensions);
     return Object.freeze({
-        verdict: verdict.verdict,
+        verdict: verdictFromDimensions(verdict.dimensions),
         score,
         dimensions: cloneDimensions(verdict.dimensions),
         overallRationale: verdict.overallRationale,
@@ -334,9 +370,10 @@ async function judgeOneCandidate(ctx, candidate, ordinal, ingestedAtoms, judge)
         return buildSyntheticWeakJudgeOutcome(ctx, candidate, ordinal, JUDGE_ERROR_RATIONALE);
     }
     const score = scoreFromDimensions(verdict.dimensions);
-    const qualityVerdict = qualityVerdictFromJudge(verdict, score);
-    if (verdict.verdict === "strong")
+    const qualityVerdict = qualityVerdictFromJudge(verdict);
+    if (qualityVerdict.verdict === "strong") {
         return { strong: true, finding: null, qualityVerdict };
+    }
     return {
         strong: false,
         finding: buildTestQualityFinding(ctx.plan.id, candidate, score, judgeRationaleSummary(verdict), ordinal),
@@ -476,10 +513,18 @@ export async function runQualityIntelligenceModelRoutedTestDesign(input, deps) {
         const generation = await withStage(ctx, "candidates", async () => generateCandidates(ctx, input, deps));
         const candidates = generation.candidates;
         const reviewCandidates = generation.reviewCandidates;
+        // A provider/parser failure is caught inside generateCandidates and degrades to the deterministic
+        // baseline (skipJudge), keeping the run alive. That degradation MUST stay visible: the redacted
+        // reason is threaded into the terminal summary (and surfaced on the wire `done` frame as
+        // `degraded` + `reasonSummary`) so the run is never presented as an authoritative model-backed
+        // result (regulated-delivery audit, QI-DEG-01).
+        const degradedReason = generation.skipJudge === true
+            ? (generation.fallbackReason ?? "qi-generation-fallback")
+            : undefined;
         emitCandidateProposed(ctx, candidates);
         const judge = deps.judge;
         const judgeResult = await withStage(ctx, "judge", async () => {
-            if (judge === undefined)
+            if (judge === undefined || generation.skipJudge === true)
                 return EMPTY_JUDGE_RESULT;
             try {
                 return await runJudgeStage(ctx, reviewCandidates, input.ingestedAtoms, judge);
@@ -493,7 +538,7 @@ export async function runQualityIntelligenceModelRoutedTestDesign(input, deps) {
             }
         });
         const atoms = input.ingestedAtoms.map((a) => a.atom);
-        const coverageMap = await withStage(ctx, "coverage", async () => Promise.resolve(buildCoverageMap({ runId: input.plan.id, atoms, candidates: reviewCandidates })));
+        const coverageMap = await withStage(ctx, "coverage", async () => Promise.resolve(buildCoverageMap({ runId: input.plan.id, atoms, candidates })));
         const atomStatuses = buildAtomCoverageStatuses(atoms, coverageMap);
         const excerptByAtomId = excerptsByAtomId(input.ingestedAtoms);
         const coverageMatrix = toCoverageMatrixRows(atomStatuses, excerptByAtomId);
@@ -504,7 +549,7 @@ export async function runQualityIntelligenceModelRoutedTestDesign(input, deps) {
                 gapFindings.push(buildCoverageGapFinding(input.plan.id, s, i, excerptByAtomId.get(String(s.atomId))));
             }
         }
-        const rawFindings = await withStage(ctx, "validate", async () => Promise.resolve(validateCandidates(input.plan.id, reviewCandidates)));
+        const rawFindings = await withStage(ctx, "validate", async () => Promise.resolve(validateCandidates(input.plan.id, candidates)));
         // Order by severity (critical -> low) BEFORE truncation so that, if the run hits the
         // per-run findings cap, the most severe findings — uncovered-requirement gaps included —
         // always survive the cut rather than being dropped by array position. Within a severity tier,
@@ -560,6 +605,7 @@ export async function runQualityIntelligenceModelRoutedTestDesign(input, deps) {
             modelGatewayCallCount: ctx.modelGatewayCallCount,
             evidence,
             qualityScore: judgeResult.qualityScore,
+            ...(degradedReason !== undefined ? { reasonSummary: degradedReason } : {}),
         });
     }
     catch (caught) {

package/node_modules/@oscharko-dev/keiko-workflows/dist/ranking/rank.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../src/ranking/rank.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,uBAAuB,EAG7B,MAAM,iDAAiD,CAAC;AAEzD,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAyC,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;CAC1C;AAsJD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CAyB/F"}
+{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../src/ranking/rank.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,uBAAuB,EAG7B,MAAM,iDAAiD,CAAC;AAEzD,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAyC,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC/C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;CAC1C;AA+JD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CAyB/F"}

package/node_modules/@oscharko-dev/keiko-workflows/dist/ranking/rank.js

@@ -7,6 +7,12 @@ import { DEFAULT_FILTER_OPTIONS, filterCandidates, } from "./filter.js";
 import { DEFAULT_SCORING_WEIGHTS, computeScore } from "./scoring.js";
 import { DEFAULT_GENERATED_PATTERNS, extractSignals, } from "./signals.js";
 const AUTO_DUPLICATE_CLUSTER_MIN = 3;
+const AUTO_DUPLICATE_BASENAME_EXEMPTIONS = new Set([
+    "agents.md",
+    "package.json",
+    "readme.md",
+    "tsconfig.json",
+]);
 function resolveHints(hints) {
     return {
         generatedPathPatterns: hints?.generatedPathPatterns ?? DEFAULT_GENERATED_PATTERNS,
@@ -67,6 +73,9 @@ function deriveDuplicateHints(group, explicit) {
             continue;
         }
         const key = basename(scopePath).toLowerCase();
+        if (AUTO_DUPLICATE_BASENAME_EXEMPTIONS.has(key)) {
+            continue;
+        }
         const existing = clusters.get(key);
         if (existing === undefined) {
             clusters.set(key, [entry]);

package/node_modules/@oscharko-dev/keiko-workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oscharko-dev/keiko-workflows",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.9",
   "private": true,
   "type": "module",
   "license": "Apache-2.0",