@skyramp/mcp 0.2.6 → 0.2.7

package/build/prompts/test-recommendation/promptPlan.d.ts

@@ -0,0 +1,203 @@
+/**
+ * PromptPlan — structured prompt composition with phases, steps, and sub-steps.
+ *
+ * Design goals:
+ * - Main steps are always non-conditional; their labels (1, 2, 3, …) are
+ *   static string constants usable in tests without calling any function.
+ * - Sub-steps are sequentially numbered within their parent (1.1, 1.2, 2.1, …).
+ *   No manually chosen suffixes — insertion or removal automatically renumbers.
+ * - Conditional sub-steps: when absent, remaining siblings re-number so the
+ *   LLM never sees a gap in the step sequence.
+ * - Phases group steps under an optional named heading with a configurable
+ *   rendering style.
+ * - preview(params) returns a structured snapshot for developer inspection:
+ *   which steps are active, what their labels are, and why conditional ones
+ *   are absent.
+ *
+ * Usage:
+ *   const _plan = new PromptPlan<MyParams>()
+ *     .addPhase("main", "Task Instructions", { headerLevel: "##", stepFormat: "hash" })
+ *     .step("READ",   "Read the files",   (p) => buildReadBody(p))
+ *     .subStep("PATHS", "Resolve paths",  (p) => buildPathsBody(p))
+ *     .step("EXTRACT", "Extract items",   (p) => buildExtractBody(p))
+ *     .subStep("TRACE", "Trace callers",  (p) => buildTraceBody(p),
+ *       { when: (p) => p.hasUnmatched, whenDesc: "unmatched backend files present" })
+ *     .step("CALL",   "Call the tool",    (p) => buildCallBody(p))
+ *     .done();
+ *
+ *   // Static constants for non-conditional steps (safe to export at module level)
+ *   export const STEP_READ    = _plan.labels.READ;    // "1"
+ *   export const STEP_PATHS   = _plan.labels.PATHS;   // "1.1"
+ *   export const STEP_EXTRACT = _plan.labels.EXTRACT; // "2"
+ *   export const STEP_CALL    = _plan.labels.CALL;    // "3"
+ *
+ *   // Dynamic accessor for the conditional sub-step
+ *   export const getStepTrace = (p: MyParams) => _plan.labelFor("TRACE", p); // "2.1" | null
+ *
+ *   // Render for the LLM
+ *   const promptText = _plan.render(params);
+ *
+ *   // Developer review
+ *   console.log(_plan.preview(params));
+ */
+export type StepBody<P> = (params: P) => string;
+/** Step title: either a static string or a function for dynamic titles. */
+export type StepTitle<P> = string | ((params: P) => string);
+export type StepCondition<P> = (params: P) => boolean;
+interface SubStepDef<P> {
+    key: string;
+    title: StepTitle<P>;
+    body: StepBody<P>;
+    condition?: StepCondition<P>;
+    conditionDesc?: string;
+}
+interface StepDef<P> {
+    key: string;
+    title: StepTitle<P>;
+    body: StepBody<P>;
+    subSteps: SubStepDef<P>[];
+}
+interface PhaseDef<P> {
+    key: string;
+    title: string;
+    headerLevel: "##" | "###" | "hidden";
+    stepFormat: "hash" | "bold";
+    steps: StepDef<P>[];
+}
+export interface SubStepPreview {
+    key: string;
+    /** Computed label if active (e.g. "2.1"), or "N.?" if conditional and absent. */
+    label: string;
+    title: string;
+    active: boolean;
+    /** Human-readable description of the condition gating this sub-step. */
+    conditionDesc?: string;
+}
+export interface StepPreview {
+    key: string;
+    label: string;
+    title: string;
+    subSteps: SubStepPreview[];
+}
+export interface PhasePreview {
+    key: string;
+    title: string;
+    steps: StepPreview[];
+}
+export interface PlanPreview {
+    phases: PhasePreview[];
+    /** Total steps (main + sub-steps) that are active for the given params. */
+    activeStepCount: number;
+    /** Total steps registered in the plan, including conditional ones. */
+    totalStepCount: number;
+}
+export declare class PhaseBuilder<P extends object> {
+    private readonly _plan;
+    private readonly _phase;
+    private _lastStep;
+    constructor(plan: PromptPlan<P>, phase: PhaseDef<P>);
+    /**
+     * Add a non-conditional main step.
+     * Main steps always appear in the rendered output and always carry a stable
+     * label (1, 2, 3, …) regardless of which sub-steps are active.
+     */
+    step(key: string, title: StepTitle<P>, body: StepBody<P>): this;
+    /**
+     * Add a sub-step under the most recently declared main step.
+     * Sub-steps are sequentially numbered within their parent (1.1, 1.2, …).
+     *
+     * When opts.when is provided the sub-step is conditional: if the condition
+     * returns false for the given params, the step is omitted and remaining
+     * siblings re-number so the LLM never sees a gap.
+     *
+     * @throws when called before any step() in this phase.
+     */
+    subStep(key: string, title: StepTitle<P>, body: StepBody<P>, opts?: {
+        when?: StepCondition<P>;
+        whenDesc?: string;
+    }): this;
+    /** Finish building this phase and return the parent PromptPlan. */
+    done(): PromptPlan<P>;
+}
+export declare class PromptPlan<P extends object> {
+    private readonly _phases;
+    private readonly _startFrom;
+    /** Track registered step/sub-step keys for duplicate detection. */
+    private readonly _registeredKeys;
+    /**
+     * @param opts.startFrom - Label of the first main step. Defaults to 1.
+     *   Use 0 for execution-plan style (Step 0, Step 1, Step 2, …).
+     */
+    constructor(opts?: {
+        startFrom?: number;
+    });
+    /** @internal Register a key and throw if already taken. */
+    _registerKey(key: string): void;
+    /**
+     * Add a phase and return a PhaseBuilder to register its steps.
+     * Multiple phases share a single global main-step counter, so step labels
+     * increment continuously across phase boundaries.
+     */
+    addPhase(key: string, title: string, opts?: {
+        /** Markdown heading level for the phase header. "hidden" emits no header. */
+        headerLevel?: "##" | "###" | "hidden";
+        /**
+         * Step header rendering style.
+         * "hash" => "### Step N: Title"  (analysis prompt style)
+         * "bold" => "**Step N — Title**" (execution plan style)
+         */
+        stepFormat?: "hash" | "bold";
+    }): PhaseBuilder<P>;
+    /**
+     * Static label map for all non-conditional steps (main steps and
+     * unconditional sub-steps). Conditional sub-steps are not present here —
+     * use labelFor() for those.
+     *
+     * Safe to export as module-level constants for use in tests.
+     *
+     * **Ordering constraint**: unconditional sub-steps that appear *after* a
+     * conditional sibling will have a stable label here only if no conditional
+     * siblings precede them. When a conditional sibling is active at runtime,
+     * labelFor() will assign a higher number than the static label here. To
+     * avoid this mismatch, place conditional sub-steps AFTER all unconditional
+     * siblings, or use labelFor() for any sub-step with a conditional predecessor.
+     *
+     * O(steps) per call — intentionally avoids a stale-cache window during plan
+     * construction. Plans have ~6 steps so the cost is negligible; exported
+     * constants are evaluated once at module-load time.
+     */
+    get labels(): Record<string, string>;
+    /**
+     * Dynamic label for any registered step given runtime params.
+     *
+     * Returns null when the step has a condition that evaluates to false.
+     * Throws when key is not registered in this plan.
+     *
+     * For non-conditional steps the result equals labels[key], but using
+     * labels is preferred for those since it avoids passing params.
+     */
+    labelFor(key: string, params: P): string | null;
+    /**
+     * Render the full prompt for the given params.
+     *
+     * - Phase headers are emitted when headerLevel is not "hidden".
+     * - Steps are formatted per the phase's stepFormat.
+     * - Conditional sub-steps absent for these params are skipped; remaining
+     *   siblings re-number with no gaps.
+     * - Each section (header + body) is separated by a single blank line.
+     */
+    render(params: P): string;
+    /**
+     * Return a structured preview of all steps and their active state for the
+     * given params. Useful in development, tests, and debugging to verify exactly
+     * which steps would be emitted and what labels they carry.
+     *
+     * @example
+     *   const pv = _plan.preview({ ...params, unmatchedFiles: [] });
+     *   // pv.phases[0].steps[1].subSteps[0] =>
+     *   //   { key: "TRACE_CALLERS", label: "2.?", active: false,
+     *   //     conditionDesc: "non-frontend unmatched backend files present" }
+     */
+    preview(params: P): PlanPreview;
+}
+export {};

package/build/prompts/test-recommendation/promptPlan.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/prompts/test-recommendation/recommendationSections.d.ts

@@ -0,0 +1,35 @@
+export declare const MAX_TESTS_TO_GENERATE = 3;
+export declare const MAX_RECOMMENDATIONS = 20;
+export declare const MAX_CRITICAL_TESTS = 3;
+/**
+ * Error string emitted by skyramp_integration_test_generation when both
+ * an explicit authHeader and a workspace api.authType are passed simultaneously.
+ * Both the tool description and all prompt locations import this constant,
+ * so every occurrence is character-for-character identical by construction.
+ */
+export declare const AUTH_CONFLICT_ERROR_MSG = "Auth header and auth type cannot be supported at the same time.";
+export declare function buildArchitectPreamble(isDiffScope: boolean): string;
+export declare function buildContextFetchingGuidance(sessionId?: string): string;
+export declare function buildReasoningProtocol(): string;
+export interface AuthCallParams {
+    authHeader: string;
+    authScheme?: string;
+    authToken?: string;
+}
+/**
+ * Returns the authScheme snippet for a given authHeader + authType combination.
+ *
+ * Delegates scheme resolution to getAuthScheme() in workspaceAuth.ts — the single
+ * source of truth — so this file no longer maintains its own slug→scheme table.
+ */
+export declare function getAuthSnippets(authHeaderValue: string, authType?: string, explicitScheme?: string): {
+    authSchemeSnippet: string;
+    authTokenSnippet: string;
+};
+export declare const PATH_PARAM_UUID_GUIDANCE: string;
+export declare function buildTestPatternGuidelines(): string;
+export declare function buildTestQualityCriteria(): string;
+export declare function buildGenerationRules(isUIOnlyPR: boolean): string;
+export declare function buildVerificationChecklist(topN: number, maxGen: number, codeReviewStepLabel?: string): string;
+export declare function buildFewShotExamples(): string;
+export declare function buildToolWorkflows(authHeaderValue: string, authTypeValue?: string, explicitScheme?: string): string;

package/build/prompts/test-recommendation/recommendationShared.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared dedup primitives used by both diff-mode (diffExecutionPlan.ts) and
+ * full-repo mode (fullRepoCatalog.ts). Extracted here to avoid circular imports.
+ */
+import { DraftedScenario } from "../../types/RepositoryAnalysis.js";
+export declare function scenarioCoverageKey(scenario: DraftedScenario): string;
+/**
+ * Method-aware coverage key for external test dedup.
+ * Unlike scenarioCoverageKey (resource::testType), this includes the HTTP method
+ * so that e.g. an external test covering "GET /orders" doesn't block generating
+ * a test for "PUT /orders" — a different operation on the same resource.
+ */
+export declare function externalDedupKey(scenario: DraftedScenario): string;
+export declare function isAttackSurfaceSecurityBoundary(scenario: DraftedScenario): boolean;
+export declare function isOrdinaryDirectAuthBoundary(scenario: DraftedScenario): boolean;
+/**
+ * Build a set of coverage keys from external (non-Skyramp) tests.
+ * Parses `testLocations` entries tagged with `[external]` to extract the
+ * method-aware `METHOD::resource::testType` keys they cover.
+ */
+export declare function buildExternalCoverageSet(testLocations: Record<string, string>): Set<string>;
+export declare const TASK_UI_PRESCAN = "0";
+export declare const TASK_ANALYZE_MAINTAIN = "1";
+export declare const TASK_GENERATE = "2";
+export declare const TASK_SUBMIT = "3";
+export declare const TESTBOT_TASK1_STEP_ANALYZE = "1";
+export declare const TESTBOT_TASK1_STEP_MAINTAIN = "2";
+export declare const TESTBOT_TASK1_STEP_CODE_REVIEW = "3";
+export declare const TESTBOT_TASK1_STEP_UI_GROUNDING = "4";
+export declare const taskRef: (taskId: string) => string;
+export declare const taskStepRef: (taskId: string, stepId: string) => string;

package/build/prompts/test-recommendation/registerRecommendTestsPrompt.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DraftedScenario } from "../../types/RepositoryAnalysis.js";
+export declare function mergeEnrichedScenarios(serverScenarios: DraftedScenario[], raw: string): {
+    scenarios: DraftedScenario[];
+    rejectionNotes: string[];
+};
+export declare function registerRecommendTestsPrompt(server: McpServer): void;

package/build/prompts/test-recommendation/scopeAssessment.d.ts

@@ -0,0 +1,55 @@
+export declare function hasFlutterSdkDep(repositoryPath: string): boolean;
+/**
+ * Returns true if the file path is a frontend file.
+ *
+ * Four tiers:
+ * 1. .vue / .svelte — always frontend; these file types cannot be route handlers.
+ * 2. .dart — always frontend IFF `hasFlutterSdkDep` is true (Flutter project).
+ *    Sits in tier 1 because there's no server-side Dart web framework in scope
+ *    when the Flutter SDK dep is present, so `API_DIR_PATTERN` doesn't apply.
+ * 3. .tsx / .jsx — frontend unless in an API/backend directory (e.g. pages/api/).
+ * 4. Ambiguous extensions (.ts, .js, .css, .html, …) — require a recognised
+ *    frontend directory AND must not be in an API/backend directory.
+ *
+ * The `hasFlutterSdkDep` opt is passed in by the budget-driving caller
+ * (analyzeChangesTool) which has repository context.
+ * Pure-path callers (test-recommendation-prompt, analysisOutputPrompt,
+ * scopeAssessment's own buildScopeAssessmentSection) default to false —
+ * they don't drive the budget.
+ */
+export declare function isFrontendFile(filePath: string, { hasFlutterSdkDep }?: {
+    hasFlutterSdkDep?: boolean;
+}): boolean;
+/**
+ * Returns true if the file path looks like a test file rather than UI source.
+ *
+ * Catches:
+ *   - Skyramp-generated tests (`*_test.ts`, `*_smoke.ts`, `*_contract.ts`,
+ *     `*_fuzz.ts`, `*_integration.ts`, `*_load.ts`, `*_e2e.ts`, `*_ui.ts`)
+ *   - Skyramp scenario files (`scenario_*.json`)
+ *   - Conventional Vitest/Jest/Playwright spec naming
+ *     (`*.spec.{ts,tsx,js,jsx}`, `*.test.{ts,tsx,js,jsx}`)
+ *   - Files inside `__tests__/` directories (Jest convention)
+ *
+ * Used by callers that want to filter test files OUT of frontend-source
+ * processing — `isFrontendFile` returns true for `.spec.ts` under a
+ * frontend directory because the rule is "tier-3 ambiguous + frontend dir,"
+ * but those tests aren't UI source we'd want to ground recommendations in.
+ */
+export declare function isTestFile(filePath: string): boolean;
+/**
+ * Builds the PR scope assessment section.
+ *
+ * When `precomputedUIPct` is provided (0 = backend-only, 100 = UI-only) the server
+ * has already determined the split unambiguously — skip Steps A–C and emit one line.
+ *
+ * For mixed PRs (`precomputedUIPct` is undefined, `hasFrontendChanges` is true) skip
+ * Steps A–C but keep Step D so the LLM can apply judgment to determine the UI%.
+ *
+ * Falls back to the full four-step assessment when no precomputed data is available.
+ */
+export declare function buildScopeAssessmentSection(maxTotal?: number, maxGenerate?: number, isUIOnly?: boolean, 
+/** Server-determined UI/E2E percentage. `undefined` = mixed PR or unknown. */
+precomputedUIPct?: number, 
+/** Whether the diff contains frontend files (true ↔ mixed PR when precomputedUIPct is undefined). */
+hasFrontendChanges?: boolean): string;

package/build/prompts/test-recommendation/scopeAssessment.js

@@ -109,8 +109,8 @@ function checkPubspec(pubspecPath) {
  * 4. Ambiguous extensions (.ts, .js, .css, .html, …) — require a recognised
  *    frontend directory AND must not be in an API/backend directory.
  *
- * The `hasFlutterSdkDep` opt is passed in by the budget-driving callers
- * (uiAnalyzeChangesTool, analyzeChangesTool) which have repository context.
+ * The `hasFlutterSdkDep` opt is passed in by the budget-driving caller
+ * (analyzeChangesTool) which has repository context.
  * Pure-path callers (test-recommendation-prompt, analysisOutputPrompt,
  * scopeAssessment's own buildScopeAssessmentSection) default to false —
  * they don't drive the budget.

package/build/prompts/test-recommendation/scopeAssessment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/prompts/test-recommendation/scopeAssessment.test.js

@@ -1,3 +1,4 @@
+import { jest } from "@jest/globals";
 jest.mock("@skyramp/skyramp", () => ({
     WorkspaceConfigManager: { create: jest.fn() },
 }));

package/build/prompts/test-recommendation/test-recommendation-prompt.d.ts

@@ -0,0 +1,6 @@
+import { RepositoryAnalysis, AnalysisScope } from "../../types/RepositoryAnalysis.js";
+import { WorkspaceAuthType } from "../../utils/workspaceAuth.js";
+import { PRTestContext } from "../../utils/pr-comment-parser.js";
+import { buildExternalCoverageSet, externalDedupKey } from "./recommendationShared.js";
+export { buildExternalCoverageSet, externalDedupKey };
+export declare function buildRecommendationPrompt(analysis: RepositoryAnalysis, analysisScope?: AnalysisScope, topN?: number, prContext?: PRTestContext, workspaceAuthHeader?: string, workspaceAuthType?: WorkspaceAuthType, workspaceAuthScheme?: string, maxGenerateOverride?: number, sessionId?: string): string;

package/build/prompts/test-recommendation/test-recommendation-prompt.js

@@ -93,10 +93,10 @@ ${isUIOnlyPR ? `\n**UI-only PR** — no backend changes. UI and E2E tests are mo
 Output should be concise and immediately actionable.`
         : `You are in **Repo mode**. Comprehensive test strategy across all endpoints.`;
     // ── UI rec authoring rules ──
-    // Anchors every UI recommendation regardless of whether the agent ran
-    // skyramp_ui_analyze_changes / browser_blueprint before this call. When the
-    // agent has prior captures in its own tool-result history, those serve as
-    // grounding; when it doesn't, recommendations fall back to source-grounded
+    // Anchors every UI recommendation regardless of whether the agent captured
+    // browser_blueprints (from the UI Blueprint Capture section this tool returns).
+    // When the agent has prior captures in its own tool-result history, those serve
+    // as grounding; when it doesn't, recommendations fall back to source-grounded
     // prose. Either way, inventing elements / leaking jargon / duplicating UI
     // tests are wrong, so the rules fire unconditionally.
     const uiRecRulesSection = `

package/build/prompts/test-recommendation/test-recommendation-prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/prompts/test-recommendation/test-recommendation-prompt.test.js

@@ -1,10 +1,11 @@
-jest.mock("@skyramp/skyramp", () => ({
+import { jest } from "@jest/globals";
+import { TestType } from "../../types/TestTypes.js";
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
     WorkspaceConfigManager: { create: jest.fn() },
 }));
-import { TestType } from "../../types/TestTypes.js";
-import { buildRecommendationPrompt, buildExternalCoverageSet, externalDedupKey } from "./test-recommendation-prompt.js";
-import { buildExecutionPlan } from "./diffExecutionPlan.js";
-import { PATH_PARAM_UUID_GUIDANCE, MAX_TESTS_TO_GENERATE, buildTestQualityCriteria, buildArchitectPreamble, buildContextFetchingGuidance, buildReasoningProtocol, buildFewShotExamples, buildVerificationChecklist, } from "./recommendationSections.js";
+const { buildRecommendationPrompt, buildExternalCoverageSet, externalDedupKey } = await import("./test-recommendation-prompt.js");
+const { buildExecutionPlan } = await import("./diffExecutionPlan.js");
+const { PATH_PARAM_UUID_GUIDANCE, MAX_TESTS_TO_GENERATE, buildTestQualityCriteria, buildArchitectPreamble, buildContextFetchingGuidance, buildReasoningProtocol, buildFewShotExamples, buildVerificationChecklist, } = await import("./recommendationSections.js");
 import { AnalysisScope } from "../../types/RepositoryAnalysis.js";
 // ---------------------------------------------------------------------------
 // Minimal fixtures
@@ -1669,100 +1670,6 @@ describe("externalDedupKey", () => {
         expect(externalDedupKey(scenario)).toBe("POST::orders::contract");
     });
 });
-describe("UI grounding guidance (Phase C D-1.a)", () => {
-    const editOrderScenario = minimalScenario({
-        scenarioName: 'edit-order',
-        description: 'edit order',
-        category: 'new_endpoint',
-        priority: 'medium',
-        steps: [
-            { order: 1, method: 'PATCH', path: '/api/v1/orders/{id}', description: 'edit', interactionType: 'success', expectedStatusCode: 200 },
-        ],
-        chainingKeys: [],
-    });
-    const uiGroundingBusinessContext = {
-        mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [],
-        draftedScenarios: [editOrderScenario],
-    };
-    const uiOnlyAnalysis = () => minimalAnalysis({
-        branchDiffContext: {
-            currentBranch: "feature", baseBranch: "main",
-            changedFiles: ['frontend/src/components/EditOrder.tsx'],
-            newEndpoints: [],
-            modifiedEndpoints: [],
-            affectedServices: [],
-        },
-        businessContext: uiGroundingBusinessContext,
-    });
-    const mixedAnalysis = () => minimalAnalysis({
-        branchDiffContext: {
-            currentBranch: "feature", baseBranch: "main",
-            changedFiles: ['frontend/src/components/EditOrder.tsx', 'backend/orders.py'],
-            newEndpoints: [{
-                    path: '/api/v1/orders/{id}',
-                    methods: [{ method: 'PATCH', sourceFile: 'backend/orders.py', interactionCount: 1 }],
-                }],
-            modifiedEndpoints: [],
-            affectedServices: [],
-        },
-        businessContext: uiGroundingBusinessContext,
-    });
-    const backendOnlyAnalysis = () => minimalAnalysis({
-        branchDiffContext: {
-            currentBranch: "feature", baseBranch: "main",
-            changedFiles: ['backend/orders.py'],
-            newEndpoints: [{
-                    path: '/api/v1/orders',
-                    methods: [{ method: 'POST', sourceFile: 'backend/orders.py', interactionCount: 1 }],
-                }],
-            modifiedEndpoints: [],
-            affectedServices: [],
-        },
-        businessContext: uiGroundingBusinessContext,
-    });
-    it("emits UI grounding block on UI-only PRs", () => {
-        const out = buildRecommendationPrompt(uiOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain("UI recommendation grounding");
-        expect(out).toContain("role=<role>");
-        expect(out).toContain("accessibleName=");
-    });
-    it("emits UI grounding block on mixed PRs", () => {
-        const out = buildRecommendationPrompt(mixedAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain("UI recommendation grounding");
-        expect(out).toContain("contextText=");
-    });
-    it("does not emit UI grounding block on backend-only PRs", () => {
-        const out = buildRecommendationPrompt(backendOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).not.toContain("UI recommendation grounding");
-    });
-    it("carves out non-UI entries from the grounding format", () => {
-        const out = buildRecommendationPrompt(mixedAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toMatch(/Contract, integration, e2e.*existing conventions/);
-    });
-    it("includes contextText example for repeating elements", () => {
-        const out = buildRecommendationPrompt(uiOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain('contextText=["customer@example.com"');
-    });
-    // Phase C D-1.a/7b: directive instruction strengthening + Validates coverage
-    // + marked fallback. Asserts the post-7b language is present.
-    it("uses MUST directive for tuple presence in reasoning field", () => {
-        const out = buildRecommendationPrompt(uiOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain("MUST contain at least three of");
-        expect(out).toContain("not valid output for UI test types");
-    });
-    it("instructs the agent to ground the Validates line for UI entries", () => {
-        const out = buildRecommendationPrompt(uiOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain("Validates line — applies to");
-        expect(out).toContain("observable behavior the test verifies");
-        expect(out).toContain("structural facts");
-    });
-    it("requires a [no-blueprint-data] marker on source-grounded fallback entries", () => {
-        const out = buildRecommendationPrompt(uiOnlyAnalysis(), AnalysisScope.CurrentBranchDiff, 10);
-        expect(out).toContain("[no-blueprint-data]");
-        expect(out).toContain("issuesFound");
-        expect(out).toContain("Do NOT silently produce ungrounded reasoning");
-    });
-});
 // ---------------------------------------------------------------------------
 // Tests — UI recommendation authoring rules
 // ---------------------------------------------------------------------------

package/build/prompts/testbot/testbot-prompts.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Service } from "../../workspace/workspace.js";
+export declare function getTestbotPrompt(prTitle: string, prDescription: string, summaryOutputFile: string, repositoryPath: string, baseBranch?: string, maxRecommendations?: number, maxGenerate?: number, _maxCritical?: number, // Reserved — accepted for API compat but not yet wired into prompt
+prNumber?: number, userPrompt?: string, services?: Service[], stateOutputFile?: string, uiCredentials?: string, testsRepoDir?: string): string;
+/**
+ * Read services from .skyramp/workspace.yml. Returns empty array if
+ * the workspace file doesn't exist or can't be parsed.
+ */
+export declare function readWorkspaceServices(repositoryPath: string): Promise<Service[]>;
+export declare function buildWorkspaceRecoveryPrefix(repositoryPath: string): string;
+export declare function registerTestbotPrompt(server: McpServer): void;