@specverse/engines 6.41.1 → 6.53.1

package/dist/realize/post-emit-verify/index.js

@@ -0,0 +1,16 @@
+/**
+ * @specverse/engines/realize/post-emit-verify — post-emit verification
+ * + feedback runner.
+ *
+ * Generic framework for running compile / lint / typecheck verifiers
+ * on the realized output and feeding errors back to the LLM for a
+ * surgical fix pass.
+ *
+ * See `specverse-self/docs/proposals/...` (TBD) for the design rationale
+ * + empirical evidence from idle-meta 2026-05-13.
+ */
+export { VERIFIERS, runAllVerifiers, findVerifier, } from './verifier-manifest.js';
+export { runPostEmitFeedback, defaultMapFileToOwner, } from './feedback-runner.js';
+export { TSC_VERIFIER } from './verifiers/tsc.js';
+export { buildLlmReemit, formatFeedbackPrompt, } from './reemit.js';
+//# sourceMappingURL=index.js.map

package/dist/realize/post-emit-verify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,OAAO,EACL,SAAS,EACT,eAAe,EACf,YAAY,GACb,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,mBAAmB,EACnB,qBAAqB,GAMtB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EACL,cAAc,EACd,oBAAoB,GAErB,MAAM,aAAa,CAAC"}

package/dist/realize/post-emit-verify/reemit.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Default `Reemit` implementation — builds a feedback prompt from
+ * verifier errors + previous file content and calls the LLM to
+ * re-emit a single file.
+ *
+ * The realize-emit skill (at ~/.claude/skills/realize-emit/) is
+ * auto-loaded by claude-cli when its description matches the prompt
+ * shape — that carries all the per-owner emission conventions
+ * (typing rules, _input convention, γ-stub shape, etc.) so the
+ * feedback re-emit benefits from the same guidance as the original
+ * emission.
+ *
+ * The prompt is intentionally minimal:
+ *   - Errors (verifier-formatted)
+ *   - Previous file content
+ *   - A request to re-emit
+ *
+ * Future iterations may augment with AVAILABLE SPEC SURFACE (cross-
+ * service signatures) when the errors are arity-shape — empirically,
+ * the skill + basic prompt suffices for most null-safety / type
+ * mismatch / unused-decl cases.
+ */
+import type { LanguageModel } from 'ai';
+import type { Reemit, ReemitRequest } from './feedback-runner.js';
+export interface BuildReemitOptions {
+    /** LLM model — same shared model used by per-owner-emit. */
+    model: LanguageModel;
+    /** Max retries per file when the LLM produces empty / unparseable
+     *  output. Default 1. */
+    maxAttempts?: number;
+    /** Per-call timeout. Default 3min — feedback re-emits are typically
+     *  faster than fresh emissions because the LLM has the previous
+     *  content to anchor on. */
+    timeoutMs?: number;
+    /**
+     * Skills whose content should be inlined into the system prompt for
+     * non-claude-cli providers. claude-cli auto-loads skills via
+     * filesystem-based resolution; other providers (`openai-compatible`,
+     * `anthropic`, `stub`) need explicit inlining of the skill content.
+     *
+     * Defaults to `['realize-emit']` — the realize-emit skill carries the
+     * per-owner emission CONSTRAINTS / GUIDANCE / EXAMPLE that's directly
+     * relevant to the feedback re-emit task (typing conventions, _input
+     * convention, γ-stub shape).
+     */
+    skills?: string[];
+}
+/**
+ * Build a `Reemit` callback that uses the provided LLM model.
+ *
+ * The returned closure can be passed straight to `runPostEmitFeedback`.
+ */
+export declare function buildLlmReemit(options: BuildReemitOptions): Reemit;
+/**
+ * Format the feedback prompt body. Caller's LLM provider (e.g.
+ * claude-cli) loads the realize-emit skill as system context.
+ *
+ * Exported for tests + so callers can override the prompt shape.
+ */
+export declare function formatFeedbackPrompt(req: ReemitRequest): string;
+//# sourceMappingURL=reemit.d.ts.map

package/dist/realize/post-emit-verify/reemit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reemit.d.ts","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/reemit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAGxC,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGlE,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,KAAK,EAAE,aAAa,CAAC;IACrB;6BACyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;gCAE4B;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CA4ClE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAqB/D"}

package/dist/realize/post-emit-verify/reemit.js

@@ -0,0 +1,122 @@
+/**
+ * Default `Reemit` implementation — builds a feedback prompt from
+ * verifier errors + previous file content and calls the LLM to
+ * re-emit a single file.
+ *
+ * The realize-emit skill (at ~/.claude/skills/realize-emit/) is
+ * auto-loaded by claude-cli when its description matches the prompt
+ * shape — that carries all the per-owner emission conventions
+ * (typing rules, _input convention, γ-stub shape, etc.) so the
+ * feedback re-emit benefits from the same guidance as the original
+ * emission.
+ *
+ * The prompt is intentionally minimal:
+ *   - Errors (verifier-formatted)
+ *   - Previous file content
+ *   - A request to re-emit
+ *
+ * Future iterations may augment with AVAILABLE SPEC SURFACE (cross-
+ * service signatures) when the errors are arity-shape — empirically,
+ * the skill + basic prompt suffices for most null-safety / type
+ * mismatch / unused-decl cases.
+ */
+import { generateText } from 'ai';
+import { assembleSystemWithSkills } from '../../ai/prompt-runner.js';
+import { resolveProviderId } from '../../ai/model-resolver.js';
+/**
+ * Build a `Reemit` callback that uses the provided LLM model.
+ *
+ * The returned closure can be passed straight to `runPostEmitFeedback`.
+ */
+export function buildLlmReemit(options) {
+    const maxAttempts = options.maxAttempts ?? 1;
+    const timeoutMs = options.timeoutMs ?? 3 * 60_000;
+    const skills = options.skills ?? ['realize-emit'];
+    // Provider-aware skill inlining: claude-cli auto-loads skills via the
+    // CLI's filesystem resolution; everyone else needs the skill content
+    // prepended to the system prompt. Compute once at build time — the
+    // provider can't change mid-loop.
+    const providerId = resolveProviderId();
+    const systemPrompt = assembleSystemWithSkills('', providerId, skills);
+    return async (req) => {
+        const prompt = formatFeedbackPrompt(req);
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const result = await Promise.race([
+                    generateText({
+                        model: options.model,
+                        prompt,
+                        // For non-claude-cli providers, `systemPrompt` carries the
+                        // skill content; for claude-cli it's empty and the CLI
+                        // auto-loads.
+                        ...(systemPrompt ? { system: systemPrompt } : {}),
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('reemit timeout')), timeoutMs)),
+                ]);
+                const extracted = extractTypeScriptBlock(result.text ?? '');
+                if (!extracted) {
+                    if (attempt + 1 < maxAttempts)
+                        continue;
+                    return null;
+                }
+                return extracted;
+            }
+            catch (err) {
+                if (attempt + 1 < maxAttempts)
+                    continue;
+                return null;
+            }
+        }
+        return null;
+    };
+}
+/**
+ * Format the feedback prompt body. Caller's LLM provider (e.g.
+ * claude-cli) loads the realize-emit skill as system context.
+ *
+ * Exported for tests + so callers can override the prompt shape.
+ */
+export function formatFeedbackPrompt(req) {
+    const errorLines = req.errors
+        .map(formatError)
+        .join('\n');
+    return [
+        `Re-emit the entire contents of \`${req.file}\`.`,
+        '',
+        `Your previous emission had the following compile / lint errors:`,
+        '',
+        errorLines,
+        '',
+        `Previous file content (re-emit this with the errors fixed):`,
+        '',
+        '```typescript',
+        req.previousContent,
+        '```',
+        '',
+        `Fix the errors and emit the ENTIRE updated file inside one \`\`\`typescript code block.`,
+        `Do not change any logic beyond what's needed to fix the errors.`,
+    ].join('\n');
+}
+function formatError(e) {
+    const pos = e.line !== undefined
+        ? `:${e.line}${e.col !== undefined ? `:${e.col}` : ''}`
+        : '';
+    return `  ${e.file}${pos} [${e.code}] ${e.message}`;
+}
+/**
+ * Pull the TypeScript code out of the LLM response. Matches the
+ * canonical ```typescript ... ``` block; falls back to ``` ... ``` if
+ * the LLM omitted the language tag.
+ */
+function extractTypeScriptBlock(text) {
+    if (!text)
+        return null;
+    const tsMatch = /```typescript\s*\n([\s\S]*?)\n```/.exec(text);
+    if (tsMatch)
+        return tsMatch[1];
+    const anyMatch = /```\s*\n([\s\S]*?)\n```/.exec(text);
+    if (anyMatch)
+        return anyMatch[1];
+    return null;
+}
+//# sourceMappingURL=reemit.js.map

package/dist/realize/post-emit-verify/reemit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reemit.js","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/reemit.ts"],"names":[],"mappings":"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"}

package/dist/realize/post-emit-verify/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Post-emit verification framework — generic interface.
+ *
+ * SpecVerse realize emits one or more LLM-authored source files per
+ * owner (e.g. `backend/src/behaviors/<Owner>.ai.ts` for the TypeScript
+ * stack). LLM emissions sometimes carry compile errors / lint issues
+ * that don't show up at per-rule validation time (the realize-rules
+ * manifest catches forbidden APIs, missing `.js` extensions, etc., but
+ * not type mismatches or runtime semantics).
+ *
+ * A `PostEmitVerifier` runs AFTER all owners have emitted, on the
+ * fully-realized output tree. It produces structured errors that the
+ * feedback runner uses to drive a per-file re-emit pass.
+ *
+ * The interface is intentionally language-agnostic. The first
+ * implementation is `tsc` for TypeScript stacks; future verifiers can
+ * target Python (`mypy`/`ruff`), Go (`go vet`), Java (`mvn compile`),
+ * Rust (`cargo check`), etc. Each verifier knows whether it `applies`
+ * given the realized target (the manifest's stack tells you).
+ *
+ * Empirical motivation: 2026-05-13 idle-meta realize at engines 6.50.1
+ * produced 48 backend tsc errors. Two hand-crafted feedback prompts
+ * (AuthController.ai.ts + FormatNumberService.ai.ts) reduced this to
+ * 37 errors with zero regressions. Extrapolation: a full feedback
+ * sweep brings idle-meta from ~48 → ~5-10 errors per realize.
+ */
+/**
+ * Single error reported by a verifier. Position-optional (some
+ * verifiers — Go vet, formatters — emit errors without precise
+ * line/col).
+ */
+export interface VerifyError {
+    /** Path to the source file, relative to the realized output dir. */
+    file: string;
+    line?: number;
+    col?: number;
+    /** Verifier-specific code, e.g. "TS2554", "py:E501", "go:S1000". */
+    code: string;
+    /** Human-readable description, suitable for inclusion in a feedback
+     *  prompt. Verifier-specific; the framework doesn't interpret it. */
+    message: string;
+    severity: 'error' | 'warning';
+}
+/**
+ * Result of running a single verifier on the realized output.
+ */
+export interface VerifyResult {
+    /** Verifier id (matches `PostEmitVerifier.id`). */
+    verifierId: string;
+    /** Wall-time. Useful for tuning verifier order + budget. */
+    durationMs: number;
+    /** Whether the verifier ran successfully. False indicates a tool-level
+     *  failure (tsc not installed, npm install needed first, etc.) — the
+     *  feedback runner SKIPS the verifier when not ok, not when errors > 0. */
+    ok: boolean;
+    errors: VerifyError[];
+    /** Non-fatal warnings from the verifier itself (separate from
+     *  per-error severity), e.g. "tsc emitted 200 errors but we truncated
+     *  to 100". */
+    notes: string[];
+}
+/**
+ * Context passed to verifiers — describes the realize target so each
+ * verifier can decide whether it `applies`.
+ *
+ * Minimal for now; extends as new verifiers need additional signal.
+ */
+export interface VerifyContext {
+    /** Absolute path to the realized output root (the dir that contains
+     *  e.g. `backend/`, `frontend/`, `tests/`). */
+    outputDir: string;
+    /** Realize target tag, e.g. 'typescript', 'python', 'go'. Set by the
+     *  realize pipeline based on the manifest's primary stack. */
+    targetLanguage?: string;
+    /** Optional: explicit subpath within outputDir to verify. tsc would
+     *  typically scope to `backend/`. Defaults to outputDir itself. */
+    subpath?: string;
+    /**
+     * When true (the default), verifiers MAY run dependency installation
+     * (`npm install` / `pip install` / etc.) before running their actual
+     * checks. Required for the in-pipeline `spv realize` invocation:
+     * realize emits a scaffolded project but doesn't install deps, so
+     * tsc/mypy/etc. wouldn't otherwise be available.
+     *
+     * Set to false in test harnesses or when the caller has already
+     * installed deps. Each verifier decides whether to honour the hint —
+     * a stub-only verifier might ignore it.
+     */
+    autoInstall?: boolean;
+}
+/**
+ * A verifier runs a quality check on the realized output. Each
+ * verifier is independent — the framework collects results from
+ * applicable verifiers, then the feedback runner decides what to do.
+ *
+ * Implementations must NOT throw on tool-level failures; return
+ * `{ ok: false, errors: [], notes: ['…'] }` instead. The framework
+ * surfaces notes to the user; throws crash the realize pipeline.
+ */
+export interface PostEmitVerifier {
+    /** Stable identifier — kebab-case. e.g. 'tsc', 'mypy', 'go-vet'. */
+    id: string;
+    /** Human-readable name for logs and audit. */
+    name: string;
+    /**
+     * Whether this verifier runs unless explicitly disabled. Mature
+     * stable verifiers ship `enabledByDefault: true` (tsc); experimental
+     * or third-party verifiers ship `false` to require an opt-in via
+     * `SPECVERSE_REALIZE_POST_VERIFY_ENABLE=<id>,<id>` env (future).
+     *
+     * Optional for backwards compatibility — missing field is treated
+     * as `true` (the original behavior).
+     */
+    enabledByDefault?: boolean;
+    /** Predicate: does this verifier apply to the given context? */
+    applies: (ctx: VerifyContext) => boolean;
+    /** Run the verifier. MUST NOT throw on tool failure (return ok:false). */
+    verify: (ctx: VerifyContext) => Promise<VerifyResult>;
+}
+/**
+ * After all verifiers have run, the feedback runner needs to map
+ * each errored file to its owning spec entity (e.g.
+ * `backend/src/behaviors/AuthController.ai.ts` → ownerName=AuthController).
+ *
+ * Each verifier MAY contribute a mapping hint via `mapFileToOwner`,
+ * but the framework falls back to a generic regex
+ * (`behaviors/(.+)\\.ai\\.ts$` for TypeScript). Verifiers for other
+ * stacks would override the mapping.
+ */
+export interface OwnerMapping {
+    /** Source file path (relative to outputDir). */
+    file: string;
+    /** Inferred owner name. null if the file can't be mapped (e.g.
+     *  shared infrastructure files generated by the framework, not by
+     *  per-owner LLM emit — those should NOT receive feedback re-emits). */
+    ownerName: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/realize/post-emit-verify/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb;yEACqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB;;+EAE2E;IAC3E,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB;;mBAEe;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B;mDAC+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB;kEAC8D;IAC9D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,EAAE,EAAE,MAAM,CAAC;IACX,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gEAAgE;IAChE,OAAO,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,0EAA0E;IAC1E,MAAM,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CACvD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb;;4EAEwE;IACxE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B"}

package/dist/realize/post-emit-verify/types.js

@@ -0,0 +1,28 @@
+/**
+ * Post-emit verification framework — generic interface.
+ *
+ * SpecVerse realize emits one or more LLM-authored source files per
+ * owner (e.g. `backend/src/behaviors/<Owner>.ai.ts` for the TypeScript
+ * stack). LLM emissions sometimes carry compile errors / lint issues
+ * that don't show up at per-rule validation time (the realize-rules
+ * manifest catches forbidden APIs, missing `.js` extensions, etc., but
+ * not type mismatches or runtime semantics).
+ *
+ * A `PostEmitVerifier` runs AFTER all owners have emitted, on the
+ * fully-realized output tree. It produces structured errors that the
+ * feedback runner uses to drive a per-file re-emit pass.
+ *
+ * The interface is intentionally language-agnostic. The first
+ * implementation is `tsc` for TypeScript stacks; future verifiers can
+ * target Python (`mypy`/`ruff`), Go (`go vet`), Java (`mvn compile`),
+ * Rust (`cargo check`), etc. Each verifier knows whether it `applies`
+ * given the realized target (the manifest's stack tells you).
+ *
+ * Empirical motivation: 2026-05-13 idle-meta realize at engines 6.50.1
+ * produced 48 backend tsc errors. Two hand-crafted feedback prompts
+ * (AuthController.ai.ts + FormatNumberService.ai.ts) reduced this to
+ * 37 errors with zero regressions. Extrapolation: a full feedback
+ * sweep brings idle-meta from ~48 → ~5-10 errors per realize.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/realize/post-emit-verify/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

package/dist/realize/post-emit-verify/verifier-manifest.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Post-emit verifier manifest — single source of truth for which
+ * verifiers ship with the realize pipeline.
+ *
+ * Adding a new verifier: append to VERIFIERS, then it auto-runs on
+ * matching realize targets via `applies`.
+ */
+import type { PostEmitVerifier, VerifyContext, VerifyResult } from './types.js';
+export declare const VERIFIERS: PostEmitVerifier[];
+/**
+ * Run all applicable verifiers against the realized output. Verifiers
+ * run in series (most are heavyweight enough that parallel doesn't
+ * help much, and series gives predictable log output). Each verifier's
+ * tool-level failures are isolated — one failure doesn't stop the
+ * others.
+ *
+ * Verifier filtering order:
+ *   1. `enabledByDefault === false` AND id NOT in `enabledOverrides` → SKIP
+ *   2. `applies(ctx)` returns false → SKIP
+ *   3. Otherwise → run
+ *
+ * Missing `enabledByDefault` field is treated as `true` (backwards-
+ * compatible default). The `enabledOverrides` parameter lets callers
+ * opt-in to experimental verifiers at run-time without changing the
+ * manifest.
+ */
+export declare function runAllVerifiers(ctx: VerifyContext, enabledOverrides?: Set<string>): Promise<VerifyResult[]>;
+export declare function findVerifier(id: string): PostEmitVerifier | undefined;
+//# sourceMappingURL=verifier-manifest.d.ts.map

package/dist/realize/post-emit-verify/verifier-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier-manifest.d.ts","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/verifier-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGhF,eAAO,MAAM,SAAS,EAAE,gBAAgB,EAOvC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,aAAa,EAClB,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC7B,OAAO,CAAC,YAAY,EAAE,CAAC,CAqBzB;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAErE"}

package/dist/realize/post-emit-verify/verifier-manifest.js

@@ -0,0 +1,55 @@
+import { TSC_VERIFIER } from './verifiers/tsc.js';
+export const VERIFIERS = [
+    TSC_VERIFIER,
+    // Future:
+    //   PY_MYPY_VERIFIER  — `mypy --strict src/`
+    //   GO_VET_VERIFIER   — `go vet ./...`
+    //   JAVA_MVN_VERIFIER — `mvn -q compile`
+    //   RUST_CARGO_CHECK_VERIFIER — `cargo check`
+];
+/**
+ * Run all applicable verifiers against the realized output. Verifiers
+ * run in series (most are heavyweight enough that parallel doesn't
+ * help much, and series gives predictable log output). Each verifier's
+ * tool-level failures are isolated — one failure doesn't stop the
+ * others.
+ *
+ * Verifier filtering order:
+ *   1. `enabledByDefault === false` AND id NOT in `enabledOverrides` → SKIP
+ *   2. `applies(ctx)` returns false → SKIP
+ *   3. Otherwise → run
+ *
+ * Missing `enabledByDefault` field is treated as `true` (backwards-
+ * compatible default). The `enabledOverrides` parameter lets callers
+ * opt-in to experimental verifiers at run-time without changing the
+ * manifest.
+ */
+export async function runAllVerifiers(ctx, enabledOverrides) {
+    const out = [];
+    for (const v of VERIFIERS) {
+        const enabledByDefault = v.enabledByDefault !== false;
+        const explicitlyEnabled = enabledOverrides?.has(v.id) ?? false;
+        if (!enabledByDefault && !explicitlyEnabled)
+            continue;
+        if (!v.applies(ctx))
+            continue;
+        try {
+            const result = await v.verify(ctx);
+            out.push(result);
+        }
+        catch (err) {
+            out.push({
+                verifierId: v.id,
+                durationMs: 0,
+                ok: false,
+                errors: [],
+                notes: [`Verifier "${v.id}" threw: ${err?.message ?? String(err)}`],
+            });
+        }
+    }
+    return out;
+}
+export function findVerifier(id) {
+    return VERIFIERS.find((v) => v.id === id);
+}
+//# sourceMappingURL=verifier-manifest.js.map

package/dist/realize/post-emit-verify/verifier-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier-manifest.js","sourceRoot":"","sources":["../../../src/realize/post-emit-verify/verifier-manifest.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,CAAC,MAAM,SAAS,GAAuB;IAC3C,YAAY;IACZ,UAAU;IACV,6CAA6C;IAC7C,uCAAuC;IACvC,yCAAyC;IACzC,8CAA8C;CAC/C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,GAAkB,EAClB,gBAA8B;IAE9B,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;QAC1B,MAAM,gBAAgB,GAAG,CAAC,CAAC,gBAAgB,KAAK,KAAK,CAAC;QACtD,MAAM,iBAAiB,GAAG,gBAAgB,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC;QAC/D,IAAI,CAAC,gBAAgB,IAAI,CAAC,iBAAiB;YAAE,SAAS;QACtD,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;YAAE,SAAS;QAC9B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACnC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnB,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,GAAG,CAAC,IAAI,CAAC;gBACP,UAAU,EAAE,CAAC,CAAC,EAAE;gBAChB,UAAU,EAAE,CAAC;gBACb,EAAE,EAAE,KAAK;gBACT,MAAM,EAAE,EAAE;gBACV,KAAK,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,YAAY,GAAG,EAAE,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;aACpE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAC5C,CAAC"}

package/dist/realize/post-emit-verify/verifiers/tsc.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TypeScript verifier — runs `tsc --noEmit` on the realized backend
+ * tree, parses error output, and returns structured `VerifyError`s.
+ *
+ * The first concrete implementation of the `PostEmitVerifier` interface.
+ * Used for any TypeScript realize target (the default stack today).
+ *
+ * Design notes:
+ *   - We rely on the realized project's own `node_modules/.bin/tsc`
+ *     and `tsconfig.json` (installed by the realize-emit step).
+ *     The framework doesn't bundle a tsc — the user's project owns
+ *     its own TypeScript version.
+ *   - `applies` checks for the presence of `tsconfig.json` in
+ *     `<outputDir>/<subpath>/`. Future stacks (e.g. a Java target)
+ *     would have their own verifier with their own `applies`.
+ *   - Output parsing matches the standard tsc message format:
+ *       `path/to/file.ts(line,col): error TSXXXX: Message text.`
+ *   - tsc tool-failure (binary missing, install needed) → ok=false
+ *     + notes explain. The feedback runner skips the verifier; the
+ *     realize pipeline does NOT crash.
+ */
+import type { PostEmitVerifier } from '../types.js';
+export declare const TSC_VERIFIER: PostEmitVerifier;
+//# sourceMappingURL=tsc.d.ts.map

package/dist/realize/post-emit-verify/verifiers/tsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsc.d.ts","sourceRoot":"","sources":["../../../../src/realize/post-emit-verify/verifiers/tsc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH,OAAO,KAAK,EACV,gBAAgB,EAIjB,MAAM,aAAa,CAAC;AAcrB,eAAO,MAAM,YAAY,EAAE,gBA8H1B,CAAC"}

package/dist/realize/post-emit-verify/verifiers/tsc.js

@@ -0,0 +1,148 @@
+/**
+ * TypeScript verifier — runs `tsc --noEmit` on the realized backend
+ * tree, parses error output, and returns structured `VerifyError`s.
+ *
+ * The first concrete implementation of the `PostEmitVerifier` interface.
+ * Used for any TypeScript realize target (the default stack today).
+ *
+ * Design notes:
+ *   - We rely on the realized project's own `node_modules/.bin/tsc`
+ *     and `tsconfig.json` (installed by the realize-emit step).
+ *     The framework doesn't bundle a tsc — the user's project owns
+ *     its own TypeScript version.
+ *   - `applies` checks for the presence of `tsconfig.json` in
+ *     `<outputDir>/<subpath>/`. Future stacks (e.g. a Java target)
+ *     would have their own verifier with their own `applies`.
+ *   - Output parsing matches the standard tsc message format:
+ *       `path/to/file.ts(line,col): error TSXXXX: Message text.`
+ *   - tsc tool-failure (binary missing, install needed) → ok=false
+ *     + notes explain. The feedback runner skips the verifier; the
+ *     realize pipeline does NOT crash.
+ */
+import { existsSync } from 'fs';
+import { join, relative } from 'path';
+import { spawnSync } from 'child_process';
+const TSC_LINE_RE = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/;
+/**
+ * Resolve the directory tsc should run in. Defaults to
+ * `<outputDir>/backend` (the canonical SpecVerse TypeScript target).
+ * Caller can override via `ctx.subpath`.
+ */
+function resolveSubpath(ctx) {
+    if (ctx.subpath)
+        return join(ctx.outputDir, ctx.subpath);
+    return join(ctx.outputDir, 'backend');
+}
+export const TSC_VERIFIER = {
+    id: 'tsc',
+    name: 'TypeScript Compiler',
+    enabledByDefault: true,
+    applies: (ctx) => {
+        if (ctx.targetLanguage && ctx.targetLanguage !== 'typescript')
+            return false;
+        const dir = resolveSubpath(ctx);
+        return existsSync(join(dir, 'tsconfig.json'));
+    },
+    verify: async (ctx) => {
+        const dir = resolveSubpath(ctx);
+        const start = Date.now();
+        const notes = [];
+        // Auto-install deps if needed. The realize pipeline emits a
+        // scaffolded project tree (package.json + tsconfig.json) but does
+        // not run `npm install`, so node_modules/.bin/tsc is missing on
+        // first verify. Without auto-install the framework would silently
+        // no-op default-on (after the engines 6.52 flip). Run `npm install`
+        // once when:
+        //   - `package.json` exists
+        //   - `node_modules/.bin/tsc` is missing
+        //   - `ctx.autoInstall !== false` (defaults to true)
+        // Bounded by a 5-min timeout — pathological dep trees fail loudly
+        // rather than hang the realize pipeline.
+        const localTsc = join(dir, 'node_modules', '.bin', 'tsc');
+        const pkgJson = join(dir, 'package.json');
+        const autoInstall = ctx.autoInstall !== false;
+        if (!existsSync(localTsc) && existsSync(pkgJson) && autoInstall) {
+            const installResult = spawnSync('npm', ['install', '--no-audit', '--no-fund', '--silent'], {
+                cwd: dir,
+                encoding: 'utf8',
+                maxBuffer: 50 * 1024 * 1024,
+                timeout: 5 * 60_000,
+            });
+            if (installResult.error || installResult.status !== 0) {
+                return {
+                    verifierId: 'tsc',
+                    durationMs: Date.now() - start,
+                    ok: false,
+                    errors: [],
+                    notes: [
+                        `tsc verifier auto-install failed in ${dir}: ${installResult.error?.message ?? `npm exit ${installResult.status}`}. Hint: run \`npm install\` manually before realize, or set ctx.autoInstall=false.`,
+                    ],
+                };
+            }
+            notes.push(`auto-installed deps in ${dir} for tsc verifier`);
+        }
+        // Locate the project-local tsc. Fall back to PATH `npx tsc` only if
+        // node_modules/.bin/tsc isn't installed yet.
+        let cmd;
+        let args;
+        if (existsSync(localTsc)) {
+            cmd = localTsc;
+            args = ['--noEmit'];
+        }
+        else {
+            cmd = 'npx';
+            args = ['--no-install', 'tsc', '--noEmit'];
+        }
+        const result = spawnSync(cmd, args, {
+            cwd: dir,
+            encoding: 'utf8',
+            maxBuffer: 50 * 1024 * 1024, // 50MB — error output on a heavy
+            // realize can be megabytes.
+        });
+        const durationMs = Date.now() - start;
+        if (result.error) {
+            return {
+                verifierId: 'tsc',
+                durationMs,
+                ok: false,
+                errors: [],
+                notes: [
+                    ...notes,
+                    `tsc could not be invoked: ${result.error.message}. ` +
+                        `Hint: run \`npm install\` in ${dir} before realizing, or ensure ` +
+                        `tsc is on PATH.`,
+                ],
+            };
+        }
+        const combined = (result.stdout ?? '') + (result.stderr ?? '');
+        const errors = [];
+        // tsc reports file paths relative to its CWD (the subpath). Convert
+        // those to paths relative to outputDir so the feedback runner's
+        // `join(outputDir, file)` resolves correctly.
+        const subpathRel = relative(ctx.outputDir, dir);
+        const toOutputRel = (file) => subpathRel === '' ? file : `${subpathRel}/${file}`;
+        for (const line of combined.split('\n')) {
+            const m = TSC_LINE_RE.exec(line.trimEnd());
+            if (!m)
+                continue;
+            errors.push({
+                file: toOutputRel(m[1]),
+                line: parseInt(m[2], 10),
+                col: parseInt(m[3], 10),
+                severity: m[4],
+                code: m[5],
+                message: m[6],
+            });
+        }
+        return {
+            verifierId: 'tsc',
+            durationMs,
+            // ok: true even when errors > 0 — that's the EXPECTED path.
+            // ok: false reserved for tool-level failures (binary missing, etc.).
+            ok: true,
+            errors,
+            notes,
+        };
+    },
+};
+//# sourceMappingURL=tsc.js.map