@kenkaiiii/ggcoder 4.3.159 → 4.3.160

package/dist/core/style-packs/index.d.ts

@@ -0,0 +1,19 @@
+import type { LanguageId } from "../language-detector.js";
+/**
+ * Load the style-pack content for a given language. Checks for a per-project
+ * override at `<cwd>/.gg/styles/<id>.md` first, falling back to the bundled
+ * pack. Returns `null` if neither exists (defensive — should not happen for
+ * any LanguageId in PACKS).
+ */
+export declare function loadPack(id: LanguageId, cwd: string): string | null;
+/**
+ * Render the full "Language Style Packs" section that gets spliced into the
+ * system prompt. Returns an empty string when the active set is empty so the
+ * caller can skip the section entirely.
+ *
+ * The output is intentionally compact: a single header followed by each pack
+ * separated by a blank line. Packs already include their own \`### <Language>\`
+ * sub-headers.
+ */
+export declare function renderStylePacksSection(active: Set<LanguageId>, cwd: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/style-packs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/style-packs/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAI1D;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAepF"}

package/dist/core/style-packs/index.js

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+import { languagesToSortedArray } from "../language-detector.js";
+import { PACKS } from "./packs.js";
+/**
+ * Load the style-pack content for a given language. Checks for a per-project
+ * override at `<cwd>/.gg/styles/<id>.md` first, falling back to the bundled
+ * pack. Returns `null` if neither exists (defensive — should not happen for
+ * any LanguageId in PACKS).
+ */
+export function loadPack(id, cwd) {
+    const overridePath = path.join(cwd, ".gg", "styles", `${id}.md`);
+    try {
+        const stat = fs.statSync(overridePath);
+        if (stat.isFile()) {
+            return fs.readFileSync(overridePath, "utf-8").trim();
+        }
+    }
+    catch {
+        /* no override — fall through to bundled */
+    }
+    return PACKS[id] ?? null;
+}
+/**
+ * Render the full "Language Style Packs" section that gets spliced into the
+ * system prompt. Returns an empty string when the active set is empty so the
+ * caller can skip the section entirely.
+ *
+ * The output is intentionally compact: a single header followed by each pack
+ * separated by a blank line. Packs already include their own \`### <Language>\`
+ * sub-headers.
+ */
+export function renderStylePacksSection(active, cwd) {
+    if (active.size === 0)
+        return "";
+    const ids = languagesToSortedArray(active);
+    const parts = [];
+    for (const id of ids) {
+        const pack = loadPack(id, cwd);
+        if (pack)
+            parts.push(pack);
+    }
+    if (parts.length === 0)
+        return "";
+    return (`## Language Style Packs\n\n` +
+        `Conventions for new code in each active language. Library names below are ` +
+        `illustrative — use whatever the project already imports.\n\n` +
+        parts.join("\n\n"));
+}
+//# sourceMappingURL=index.js.map

package/dist/core/style-packs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/style-packs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAc,EAAE,GAAW;IAClD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACjE,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YAClB,OAAO,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;QACvD,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,2CAA2C;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC;AAC3B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAAuB,EAAE,GAAW;IAC1E,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACjC,MAAM,GAAG,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,MAAM,IAAI,GAAG,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAC/B,IAAI,IAAI;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAClC,OAAO,CACL,6BAA6B;QAC7B,4EAA4E;QAC5E,8DAA8D;QAC9D,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CACnB,CAAC;AACJ,CAAC"}

package/dist/core/style-packs/packs.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageId } from "../language-detector.js";
+/**
+ * Per-language style packs injected into the system prompt when the detector
+ * sees the language is active in the project.
+ *
+ * Design principles (apply to every pack):
+ *   1. Apply the strictest reasonable subset of *idiomatic* style — nothing
+ *      exotic the model has to think about. The agent already knows these
+ *      patterns; the pack just narrows the choice space.
+ *   2. Optimize for low ambiguity, not for human readability. Bullet form.
+ *   3. Errors as values, schema at boundaries, mechanical formatting,
+ *      one canonical way to do common tasks.
+ *   4. ~30-50 lines per pack. Anything longer is bloat in the system prompt.
+ *   5. Avoid triple backticks (template literal conflict). Use single
+ *      backticks for inline tokens, escape with \\\` when needed.
+ */
+export declare const PACKS: Readonly<Record<LanguageId, string>>;
+//# sourceMappingURL=packs.d.ts.map

package/dist/core/style-packs/packs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packs.d.ts","sourceRoot":"","sources":["../../../src/core/style-packs/packs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CA2OtD,CAAC"}

package/dist/core/style-packs/packs.js

@@ -0,0 +1,228 @@
+/**
+ * Per-language style packs injected into the system prompt when the detector
+ * sees the language is active in the project.
+ *
+ * Design principles (apply to every pack):
+ *   1. Apply the strictest reasonable subset of *idiomatic* style — nothing
+ *      exotic the model has to think about. The agent already knows these
+ *      patterns; the pack just narrows the choice space.
+ *   2. Optimize for low ambiguity, not for human readability. Bullet form.
+ *   3. Errors as values, schema at boundaries, mechanical formatting,
+ *      one canonical way to do common tasks.
+ *   4. ~30-50 lines per pack. Anything longer is bloat in the system prompt.
+ *   5. Avoid triple backticks (template literal conflict). Use single
+ *      backticks for inline tokens, escape with \\\` when needed.
+ */
+export const PACKS = {
+    typescript: `### TypeScript
+
+- **Tooling.** \`tsc --strict\` always. Enable \`noUncheckedIndexedAccess\`, \`exactOptionalPropertyTypes\`, \`noImplicitOverride\`. Prettier + \`@typescript-eslint/strict-type-checked\`.
+- **Types.** Explicit return types on every exported function and async function. Inference is fine inside function bodies. Never use \`any\`. Never use \`as\` casts except \`as const\`. Never use the non-null \`!\` operator. Ban the \`Function\` type and \`Object\` type.
+- **Data.** Validate every external boundary (HTTP, env, file, IPC) with Zod or Valibot. Never trust untyped JSON. Discriminated unions over class hierarchies. \`Readonly<T>\` for immutable shapes.
+- **Errors.** Use \`Result<T, E>\` (e.g. \`neverthrow\`) for expected failures — network errors, validation failures, missing records. Reserve \`throw\` for truly unrecoverable bugs (impossible states, assertion failures). Never throw for control flow.
+- **Modules.** Named exports only — no \`export default\`. One concept per file. No barrel files (\`index.ts\` re-exports). Feature folders (\`users/\`), not layer folders (\`controllers/services/repos/\`).
+- **Async.** \`async/await\` only — no \`.then\` chains. Always await or explicitly return promises. No floating promises.
+- **Avoid.** \`enum\` (use \`as const\` objects + \`typeof\` unions). Class inheritance beyond one level. \`namespace\`. Decorators outside framework-required slots. Conditional/mapped types in app code (keep in \`types.ts\` if unavoidable).`,
+    javascript: `### JavaScript
+
+- **Tooling.** ESM only (\`"type": "module"\`). Prettier + ESLint with \`eslint:recommended\` and \`eslint-plugin-import\`. If types matter at all, use TypeScript instead of JSDoc.
+- **Types.** If you must stay on JS, annotate exported functions with JSDoc \`@param\`/\`@returns\` so the LSP can infer. Otherwise treat the project as untyped and validate aggressively at boundaries.
+- **Data.** Validate every external boundary with Zod. Use plain objects + factory functions, not classes, for data shapes. \`Object.freeze\` for constants.
+- **Errors.** Return \`{ ok: true, value } | { ok: false, error }\` discriminated objects for expected failures. \`throw\` only for unrecoverable bugs. Always handle promise rejections.
+- **Modules.** Named exports only. One concept per file. Use feature folders. No CommonJS \`require\` in new code.
+- **Async.** \`async/await\` exclusively. \`Promise.all\` for parallel work; never sequential awaits in a loop unless ordering is required.
+- **Avoid.** \`var\`. Implicit globals. \`==\` (use \`===\`). Prototype mutation. \`with\`. \`eval\`. \`arguments\` (use rest params).`,
+    python: `### Python
+
+- **Tooling.** Python 3.12+. Ruff (lint + format) and Pyright in strict mode. \`pyproject.toml\` is the single config file — no \`setup.py\`, \`setup.cfg\`, or \`requirements.txt\` in new projects. Use \`uv\` for env/dep management.
+- **Types.** Annotate every parameter, return, and class field. Use built-in generics: \`list[str]\`, \`dict[str, int]\`, \`X | None\` (not \`Optional\`). Never bare \`Any\`. \`TypedDict\` for dict shapes only at API boundaries; prefer dataclasses or Pydantic models for everything else.
+- **Data.** Internal value objects: \`@dataclass(slots=True, frozen=True)\`. External boundaries (HTTP, files, env, IPC): Pydantic v2 \`BaseModel\` with \`model_config = ConfigDict(strict=True, frozen=True)\`. Pydantic guards the boundary; type checker guards the interior.
+- **Errors.** Raise specific custom exceptions for unrecoverable bugs. For expected failures, return \`tuple[T, None] | tuple[None, ErrorType]\` or a small \`Result\` dataclass. Never use bare \`except:\` — always catch a specific class.
+- **Structure.** One concept per module. \`src/\` layout. No top-level mutable state. \`__init__.py\` re-exports only public API. Feature folders.
+- **Idioms.** \`match\` statements over \`isinstance\` chains. Discriminated unions via \`Literal\` tag fields. Comprehensions over \`map\`/\`filter\`. \`pathlib.Path\`, never raw string paths.
+- **Avoid.** Decorators that mutate (use \`@dataclass\`, \`@property\`, \`@staticmethod\`, framework-required only). \`*args\`/\`**kwargs\` except at adapter edges. Mutable default arguments. \`from x import *\`. Circular imports — refactor into a smaller module.`,
+    go: `### Go
+
+- **Tooling.** \`gofmt\` non-negotiable. \`go vet\` + \`staticcheck\` in CI. \`golangci-lint\` with a conservative preset. Latest stable Go.
+- **Errors.** \`if err != nil { return fmt.Errorf("doing X: %w", err) }\` — wrap with context at every layer. Define sentinel errors as \`var ErrXxx = errors.New("xxx")\` at package level. Use \`errors.Is\`/\`errors.As\` for matching. Never \`panic\` outside \`init\` or truly impossible states.
+- **Types.** Small interfaces defined at the consumer, not the producer (\`io.Reader\`-style, 1-3 methods). Accept interfaces, return structs. No empty interface \`any\` except at adapter boundaries.
+- **Concurrency.** \`context.Context\` is the first parameter on every I/O or long-running function — always propagate, never \`context.Background()\` deep in a call chain. Goroutines launched only with clear lifecycle ownership (\`errgroup\`, \`sync.WaitGroup\`, or paired \`done\` channel).
+- **Structure.** Flat package layout by feature (\`user/\`, \`order/\`), not by layer. \`cmd/<binary>/main.go\` for executables. \`internal/\` for packages not meant to be imported externally. No \`utils\` or \`common\` packages.
+- **Generics.** Use only when they remove real duplication. Concrete types are the default.
+- **Avoid.** \`init()\` functions with side effects. Global mutable state. Returning bare \`error\` without wrapping context. Naked returns in functions longer than 5 lines. \`interface{}\` in new code.`,
+    rust: `### Rust
+
+- **Tooling.** \`rustfmt\` + \`clippy\` with at minimum \`-W clippy::pedantic\`. Stable channel unless you have a specific reason. \`cargo test\` + \`cargo doc\` in CI.
+- **Errors.** Libraries: define typed error enums with \`thiserror\` so callers can match specific variants. Binaries / application code: use \`anyhow::Result\` + \`.context("doing X")\`. Use the \`?\` operator everywhere; reserve \`match\` for cases that need transformation. Never \`unwrap()\` outside tests, examples, or proven-impossible states (add \`// SAFETY:\` comment when truly unavoidable).
+- **Types.** Prefer concrete types and \`impl Trait\` returns over \`dyn Trait\` + generics towers. Newtype wrappers (\`struct UserId(Uuid)\`) over raw primitives for domain types. Lifetimes named meaningfully (\`'src\`, \`'arena\`), not \`'a\`, \`'b\`.
+- **Modules.** One concept per file. \`mod.rs\` only re-exports. Feature folders. \`pub(crate)\` by default; \`pub\` only for genuine library API.
+- **Async.** \`tokio\` is the default runtime. \`async fn\` in traits via \`async-trait\` only when stable async-fn-in-trait won't work. Avoid mixing runtimes.
+- **Unsafe.** Forbidden in app code without an explicit \`// SAFETY:\` comment explaining the invariant. Encapsulate in a safe wrapper module.
+- **Avoid.** Macro-heavy crates in app logic. Custom \`macro_rules!\` unless it removes >5 real call sites. Trait towers. \`Box<dyn Error>\` (use \`anyhow::Error\`). String-typed APIs where an enum would do.`,
+    java: `### Java
+
+- **Tooling.** Java 21+ (LTS). \`google-java-format\` or \`spotless\`. Error Prone + Checker Framework or NullAway in CI. Maven or Gradle Kotlin DSL — pick one per repo and stick.
+- **Types.** Use \`record\` for all immutable data carriers. \`sealed interface\` + permits for sum types; pattern-match in \`switch\`. \`Optional<T>\` for return types only — never as a field or parameter.
+- **Errors.** Custom unchecked exceptions extending \`RuntimeException\` for business errors. Wrap checked exceptions at adapter boundaries — don't propagate \`IOException\` through service layers. Use sealed \`Result<T, E>\` types for cases where the caller must handle both branches.
+- **Nullability.** \`@Nullable\`/\`@NonNull\` (JSpecify) on every API boundary. Treat unannotated as non-null. NullAway in CI.
+- **Structure.** Package by feature. Constructor injection only — no field injection, no setter injection. No static mutable state. \`final\` by default on classes and fields.
+- **Avoid.** Reflection in business code (frameworks may need it). Lombok in new code (records cover 95% of cases). AOP / proxy magic. Checked exceptions on new APIs. Inheritance beyond one level.`,
+    kotlin: `### Kotlin
+
+- **Tooling.** Kotlin 2.0+. \`ktlint\` + \`detekt\`. Strict explicit API mode in libraries.
+- **Types.** \`data class\` for value objects. \`sealed class\` / \`sealed interface\` for sum types — exhaustive \`when\` over \`if\`. Inline \`value class\` for domain primitives. Avoid \`Any\` and platform types.
+- **Nullability.** Use the type system — never \`!!\`. Prefer \`?.let\`, \`requireNotNull\`, or explicit \`if\` checks. Treat all Java interop returns as nullable.
+- **Errors.** \`Result<T>\` or a custom sealed \`Either\`-like type for expected failures. Reserve exceptions for bugs. \`runCatching\` only at adapter edges.
+- **Coroutines.** Structured concurrency via \`coroutineScope\` / \`supervisorScope\`. Never \`GlobalScope\`. \`Dispatchers.IO\` for blocking work, \`Default\` for CPU. Always pass a \`CoroutineContext\` or scope into suspend functions that launch children.
+- **Structure.** Package by feature. One top-level public declaration per file (extension functions excepted). Use \`internal\` visibility liberally.
+- **Avoid.** Companion-object factories when a top-level function works. Nested classes for grouping (use packages). Reflection. Overusing operator overloading.`,
+    csharp: `### C#
+
+- **Tooling.** C# 12+ on .NET 8+. \`<Nullable>enable</Nullable>\` and \`<TreatWarningsAsErrors>true</TreatWarningsAsErrors>\` project-wide. \`dotnet format\`. Roslyn analyzers + StyleCop.
+- **Types.** \`record\` (positional or with-init) for DTOs and value objects. \`required\` properties over multi-arg constructors. File-scoped namespaces. One public type per file.
+- **Nullability.** NRTs on, no \`!\` operator except for proven-non-null cases with a comment. \`is null\` / \`is not null\` over \`==\`.
+- **Errors.** Custom exceptions for unrecoverable. \`Result<T, E>\` (e.g. via \`OneOf\`, \`ErrorOr\`, or a small custom type) for expected failures across service boundaries. Never use exceptions for control flow.
+- **Async.** \`async Task<Result<T>>\` everywhere. No \`async void\` except event handlers. Always pass \`CancellationToken\` through I/O calls. Avoid \`.Result\`, \`.Wait()\`, and \`.GetAwaiter().GetResult()\` — they deadlock.
+- **LINQ.** Keep chains shallow (≤ 3 operators). Pull complex queries into named methods or local functions.
+- **Avoid.** Reflection in hot paths. Static mutable state. Source generators in app code (libraries only). Multi-level inheritance. Manual \`IDisposable\` when \`using\` works.`,
+    cpp: `### C++
+
+- **Tooling.** C++20 minimum, C++23 when toolchain allows. \`clang-format\` + \`clang-tidy\` with \`cppcoreguidelines-*\` and \`modernize-*\` checks. AddressSanitizer + UBSan in test builds. CMake with presets.
+- **Resources.** RAII universal. \`std::unique_ptr\` by default, \`std::shared_ptr\` only when ownership is genuinely shared. Never raw owning pointers. Never \`new\`/\`delete\` in app code.
+- **Types.** \`std::string_view\` and \`std::span\` for non-owning views. \`std::optional<T>\` for nullable returns. \`auto\` for obvious types, explicit for API surfaces.
+- **Errors.** \`std::expected<T, E>\` (C++23) — or \`tl::expected\` if stuck on older toolchain — for expected failures. \`throw\` only for genuinely exceptional cases (allocation failure, programmer errors). Exception specifications via \`noexcept\` on functions that must not throw.
+- **Generics.** Concepts (C++20), never SFINAE. \`std::ranges\` over raw iterator pairs.
+- **Headers/modules.** C++20 modules when supported; otherwise include guards via \`#pragma once\`. No transitive includes — each file includes what it uses.
+- **Avoid.** C-style casts (use \`static_cast\` / \`reinterpret_cast\`). Raw arrays in new code (use \`std::array\` or \`std::vector\`). Macros for anything other than include guards or platform conditionals. Template metaprogramming beyond \`if constexpr\` + concepts. Multiple inheritance of non-interface classes.`,
+    c: `### C
+
+- **Tooling.** C11 or C17. \`clang-format\` + \`clang-tidy\`. \`-Wall -Wextra -Wpedantic -Werror\` always. AddressSanitizer + UBSan in test builds. Run a fuzzer on parsers.
+- **Memory.** Pair every \`malloc\` with a clear owner and a single \`free\` site. Prefer arena/region allocators for groups of related allocations. Zero-initialize structs. Never trust \`strlen\` on untrusted input — track lengths explicitly.
+- **Types.** \`stdint.h\` integer types (\`int32_t\`, \`size_t\`, \`uintptr_t\`) — never bare \`int\`/\`long\` for sizes or counts. \`bool\` from \`stdbool.h\`. Use \`enum\` for tagged unions; carry a tag field.
+- **Errors.** Return \`int\` status codes or a small enum; pass results back via out-pointers. Always check return values. Define \`Result_T\` structs for richer cases. Never use \`errno\` across thread boundaries without copying.
+- **Structure.** One concept per \`.c\` + \`.h\` pair. Header declares public API only; static functions are file-local. No global mutable state (use opaque handles).
+- **Strings.** Length-prefixed slices or explicit \`(ptr, len)\` pairs over null-terminated wherever possible. \`snprintf\` with explicit buffer sizes — never \`sprintf\`, \`strcpy\`, \`gets\`.
+- **Avoid.** Macros beyond \`#include\` guards, platform conditionals, and named constants. Variable-length arrays. Implicit int. \`goto\` except for unified cleanup paths.`,
+    ruby: `### Ruby
+
+- **Tooling.** Ruby 3.3+. \`standardrb\` or \`rubocop\` (strict preset). \`sorbet\` with \`# typed: strict\` on every file in new projects. RSpec for tests.
+- **Types.** \`T::Struct\` (Sorbet) for value objects. \`T.nilable\`, \`T::Array[X]\`, etc. on every method signature. RBS files alongside libraries.
+- **Errors.** Custom exception classes per domain, inheriting a single base \`AppError\`. \`raise\` for unrecoverable; for expected failures return \`Success(value)\` / \`Failure(err)\` via \`dry-monads\` or a small custom Result type.
+- **Structure.** Files match class names. Modules by feature. \`Zeitwerk\` autoloading. Frozen string literals magic comment at the top of every file.
+- **Idioms.** \`Data.define\` (Ruby 3.2+) for immutable value objects when not using Sorbet. Keyword arguments over positional past 2 args. Guard clauses over nested \`if\`. \`tap\` for side effects on a chain.
+- **Avoid.** \`method_missing\` and \`respond_to_missing?\` in new code. Monkey-patching core classes. \`define_method\` at runtime. \`eval\` family. Heavy DSLs outside the few canonical cases (Rails routes, RSpec, etc. — isolate them).`,
+    php: `### PHP
+
+- **Tooling.** PHP 8.3+. PHPStan or Psalm at max level. \`php-cs-fixer\` or \`pint\`. Composer with strict autoload.
+- **Types.** \`declare(strict_types=1);\` at the top of every file. Type every parameter, return, and property. \`readonly\` classes and properties everywhere possible. Enums (backed) for closed sets — never string constants.
+- **Data.** Constructor property promotion for DTOs: \`public function __construct(public readonly string $name, public readonly int $age) {}\`. Final classes by default.
+- **Errors.** Typed custom exceptions per domain. For expected failures, return a small \`Result\` value object or use a discriminated union of result classes. Never catch \`\\\\Throwable\` except at the request boundary.
+- **Structure.** PSR-4 autoloading. Package by feature. No global state. Constructor injection only.
+- **Avoid.** Untyped parameters or returns. \`@\` error suppression. Globals. Static mutable state. Multiple inheritance via traits as a workaround for poor design. \`extract()\`, \`compact()\`, variable variables.`,
+    swift: `### Swift
+
+- **Tooling.** Swift 5.10+ or 6 with strict concurrency. \`swift-format\` or SwiftLint. \`-warnings-as-errors\` in CI.
+- **Types.** \`struct\` by default; \`class\` only for identity-bearing references. \`enum\` with associated values for sum types. \`@frozen\` on stable public enums. Generics over protocol existentials when possible.
+- **Optionals.** Use the type system — no \`!\` force-unwraps except for genuinely impossible-to-fail cases (with a comment). \`guard let\` / \`if let\` everywhere else.
+- **Errors.** \`throws\` + typed \`throws\` (Swift 6) for expected failures across module boundaries. \`Result<Success, Failure>\` when storing/passing async outcomes. Never use \`try!\` outside tests.
+- **Concurrency.** \`async\`/\`await\` + structured concurrency (\`TaskGroup\`, \`async let\`). Actors for mutable shared state. \`@MainActor\` on UI-touching code. Avoid \`Task.detached\`.
+- **Structure.** One public type per file. Group files by feature. Extensions for protocol conformances, kept in the same file unless cross-cutting.
+- **Avoid.** Implicit-unwrapped optionals (\`Type!\`) in new code. \`NSObject\` inheritance unless interop requires it. Singletons as the primary state container. Reflection (\`Mirror\`) in hot paths.`,
+    scala: `### Scala
+
+- **Tooling.** Scala 3. \`scalafmt\` + \`scalafix\`. \`-Wunused:all\`, \`-Werror\`, \`-explain\` compiler flags. Run on the latest stable Scala 3.
+- **Types.** \`case class\` for records, \`enum\` for sum types — never sealed-trait-and-case-objects boilerplate in Scala 3. Opaque types for domain primitives. Avoid implicit conversions; use \`given\`/\`using\` for type-class instances only.
+- **Errors.** \`Either[E, A]\` for expected failures, \`Try\` only at the foreign-exception boundary, exceptions only for unrecoverable bugs. With effect libraries (Cats Effect / ZIO): use the effect type's error channel.
+- **Effects.** Pick one effect system per repo (Cats Effect IO or ZIO) and stick with it. Avoid mixing Future + IO. Tagless final only when the abstraction is genuinely load-bearing.
+- **Structure.** Package by feature. One top-level definition per file when public. Heavy use of \`extension\` methods over implicit classes.
+- **Avoid.** \`null\`. \`var\` in business code. Implicit conversions. Operator-soup DSLs in app logic (libraries only). \`asInstanceOf\` outside adapter boundaries.`,
+    elixir: `### Elixir
+
+- **Tooling.** Latest stable Elixir + Erlang/OTP. \`mix format\`. \`credo --strict\` + \`dialyzer\` (with \`@spec\` on every public function).
+- **Types.** \`@spec\` and \`@type\` on every public function and module — feed Dialyzer. Use structs (\`defstruct\` + \`@enforce_keys\`) for domain data, never bare maps for typed records.
+- **Errors.** \`{:ok, value} | {:error, reason}\` tuples for expected outcomes. \`with\` chains for happy-path composition. Bang functions (\`!\`) raise on failure — use sparingly, only when callers genuinely can't recover. Never \`rescue\` arbitrary exceptions in business code.
+- **Processes.** Use OTP behaviors (\`GenServer\`, \`Supervisor\`, \`Task.Supervisor\`) — never raw \`spawn\`/\`spawn_link\` in app code. Let-it-crash with a supervision tree, not defensive try/rescue.
+- **Structure.** Context modules (Phoenix-style) group functionality by bounded context. Public API on the context module; implementation modules are internal.
+- **Avoid.** Macros in app code (libraries may need them; mark with care). \`Process.put\`/\`get\` for state. Atom-keyed maps from untrusted input (\`String.to_atom\` on user data leaks). Hidden side effects in pipelines.`,
+    haskell: `### Haskell
+
+- **Tooling.** GHC 9.6+. \`ormolu\` or \`fourmolu\`. HLint with strict suggestions. Stack or Cabal — pick one per repo. \`-Wall -Wcompat -Werror\` for libraries.
+- **Types.** Explicit top-level signatures on every binding, even when inferable. Records with named fields and \`DuplicateRecordFields\` + \`OverloadedRecordDot\` (or use \`generic-lens\`). Newtype wrappers for domain primitives.
+- **Errors.** \`Either ErrorType a\` for expected failures. \`Maybe\` only for genuine absence, not for "computation failed". Exceptions only at the IO boundary; convert to \`Either\` immediately.
+- **Effects.** Pick one effect strategy per repo: plain \`IO\` for simple apps, \`ReaderT\` over \`IO\` for typical services, or a single effect system (effectful / freer-simple). Don't mix.
+- **Structure.** One module per type + its operations. No \`Util\` or \`Misc\` modules. Public API surface in module export lists — never \`module X where\` with no export list.
+- **Avoid.** Partial functions (\`head\`, \`!!\`, \`fromJust\`) — use total alternatives. Lens-heavy chains in app logic. \`undefined\` in committed code. Orphan instances.`,
+    ocaml: `### OCaml
+
+- **Tooling.** OCaml 5+ via opam. \`dune\` build system. \`ocamlformat\` with the project preset locked. Merlin for editor support.
+- **Types.** Annotate every public binding in \`.mli\` interface files. Phantom types or private types for domain invariants. Avoid open polymorphic variants in libraries (use plain variants).
+- **Errors.** \`Result.t\` from the stdlib for expected failures. Exceptions only for impossible states or at the I/O boundary. \`( let* )\` syntax for monadic chaining over nested \`match\`.
+- **Modules.** Heavy use of modules and module signatures. One main type per module, named \`t\`, with operations as \`Module.op\`. Functors only when they buy real abstraction; otherwise plain modules.
+- **Structure.** One \`.ml\` per concept with a matching \`.mli\` exposing only public API. Dune libraries grouped by feature.
+- **Avoid.** \`Obj.magic\` outside truly unavoidable interop. Global mutable state. Polymorphic equality (\`=\`) on complex types — use type-specific \`equal\` functions. Pervasives \`Stdlib\` shadowing without a clear reason.`,
+    fsharp: `### F#
+
+- **Tooling.** Latest stable F# on .NET 8+. \`fantomas\` formatter. \`<TreatWarningsAsErrors>true</TreatWarningsAsErrors>\`. FSharpLint or analyzers.
+- **Types.** Records and discriminated unions for all domain types. Single-case DUs for domain primitives. Avoid classes in new code except for interop. Type providers only when the source schema is stable.
+- **Errors.** \`Result<'T, 'TError>\` for expected failures, \`Option\` for absence. \`ResultBuilder\` (\`result { ... }\`) computation expression for sequencing. Exceptions only at the .NET interop boundary.
+- **Structure.** Modules over classes. File order matters in F# — put types and core helpers first, composition later. One concept per file. Keep \`open\` statements at the top.
+- **Async.** \`Async\` for F#-native flows, \`Task\` at .NET boundaries. Use \`task { }\` computation expression when interop matters.
+- **Avoid.** Mutable state outside small, well-contained pockets. Object expressions where a module function would do. \`obj\` and downcasts in business code. \`null\` even for interop — wrap immediately in \`Option\`.`,
+    clojure: `### Clojure
+
+- **Tooling.** Latest stable Clojure. \`clj-kondo\` linter (treat warnings as errors). \`cljfmt\` formatter. \`tools.deps\` (\`deps.edn\`) over Leiningen for new projects.
+- **Specs/schemas.** Use Malli (preferred) or Spec at every external boundary. Schema-driven generative tests on core data. Keep schemas alongside the namespace they describe.
+- **Errors.** Return \`{:ok ...}\` / \`{:error ...}\` maps for expected failures. \`ex-info\` with structured data for genuine exceptions. Never bare \`throw\` of a string. \`try\`/\`catch\` only at process or request boundaries.
+- **State.** Atoms for shared local state, refs only when coordination is required, never global vars for mutable state. Components / Integrant / Mount for system lifecycle — pick one per repo.
+- **Structure.** Namespace per concept. Keep functions small, composable, pure where possible. Side effects pushed to the edge.
+- **Avoid.** Macros in app code unless they remove genuine ceremony. Dynamic vars (\`*var*\`) for hidden parameters. \`def\` inside functions. \`eval\` in production code. Threading-macro chains longer than ~5 steps without a named intermediate.`,
+    dart: `### Dart
+
+- **Tooling.** Dart 3+. \`dart format\`. \`very_good_analysis\` or \`flutter_lints\` strict preset. Sound null safety enabled.
+- **Types.** Explicit types on every public API. \`final\` everywhere unless mutation is intentional. Records (Dart 3) and patterns for ad-hoc structured data. \`sealed class\` + pattern matching for sum types.
+- **Errors.** Custom exceptions for unrecoverable cases. \`Result<T, E>\` sealed class for expected failures. Never throw \`String\` or untyped values.
+- **Async.** \`async\`/\`await\`. \`Future\` for one-shot, \`Stream\` for sequences. Always handle errors via \`.catchError\` or try/catch at the boundary.
+- **Structure.** One public class per file. Feature folders. \`part\`/\`part of\` only for code generation (\`freezed\`, \`json_serializable\`).
+- **Avoid.** \`dynamic\` in new code. Implicit \`new\` (write it out where ambiguous). \`var\` for public API. Mutable static fields. Long widget build methods — extract.`,
+    lua: `### Lua
+
+- **Tooling.** Lua 5.4 or LuaJIT — declare which. \`stylua\` for formatting. \`luacheck\` with strict globals. Annotate with LuaCATS / EmmyLua for editor support.
+- **Types.** \`---@type\`, \`---@param\`, \`---@return\` annotations on every public function. \`---@class\` for tables used as records.
+- **Tables.** Decide if a table is a record, array, or map at the call site and stick to it. Don't mix array and map fields. Sequence tables (\`{ "a", "b" }\`) treated as 1-indexed sequences without holes.
+- **Errors.** Return \`value, nil\` on success / \`nil, errString\` on failure for expected outcomes. \`error()\` only for unrecoverable programmer errors. \`pcall\` at module / request boundaries.
+- **Modules.** \`local M = {}; … return M\` pattern. No global side effects on require. \`local\` everything unless explicit module export.
+- **Avoid.** Implicit globals — set \`luacheck\` to flag them. Metatable cleverness in app logic. \`setfenv\`/\`getfenv\` (gone in 5.2+) or environment hacks. String-key tables when an index would work.`,
+    zig: `### Zig
+
+- **Tooling.** Pin a specific Zig version per project (the language is pre-1.0 and shifting). \`zig fmt\`. Run all sanitizers in test builds.
+- **Errors.** Use Zig's error union type \`!T\` everywhere appropriate. Define a single error set per module, named \`Error\`. Use \`try\` for propagation, \`catch\` for handling at the boundary. Never \`unreachable\` in production paths.
+- **Memory.** Explicit allocator passed in to every function that allocates. Pair every \`alloc\` with a \`defer\` \`free\`. Use arena allocators for grouped lifetimes.
+- **Comptime.** Use \`comptime\` for genuine compile-time work (generics, config) — not as a substitute for runtime code.
+- **Structure.** One concept per file. Public API at the top. Tests in the same file as the code they test.
+- **Avoid.** \`@cImport\` outside a single \`c.zig\` boundary module. Heap allocation in hot paths when a fixed-size buffer works. Mixing different allocators in one ownership chain.`,
+    sql: `### SQL
+
+- **Tooling.** \`sqlfluff\` with a strict dialect-specific preset. Migrations are append-only, numbered, and reversible — never edit an applied migration.
+- **Style.** Uppercase keywords. One clause per line, trailing commas in select lists, leading commas allowed if the team agrees. Always alias tables; always qualify columns with the alias.
+- **Selects.** Never \`SELECT *\` in application code. CTEs over nested subqueries. Window functions over self-joins where they work.
+- **Schema.** Explicit \`NOT NULL\` on every column that should have it. Foreign keys with \`ON DELETE\` actions specified. Generated/identity columns for surrogate keys; never auto-incrementing without a \`PRIMARY KEY\`.
+- **Migrations.** One change per migration. Idempotent where the engine supports it. Always include a rollback plan in a comment. No data migrations mixed with schema migrations.
+- **Avoid.** String interpolation into queries from app code — use parameterized queries. \`SELECT INTO\` for permanent tables. ORM lazy-loading patterns hidden behind \`N+1\` queries. Wide tables with \`JSON\` columns where a relational design fits.`,
+    bash: `### Bash / Shell
+
+- **Tooling.** \`#!/usr/bin/env bash\` shebang. \`set -euo pipefail; IFS=$'\\n\\t'\` at the top of every script. \`shellcheck\` clean — no exceptions.
+- **Style.** Quote every variable expansion (\`"$var"\`). \`[[ ]]\` not \`[ ]\` for tests. \`$(cmd)\` not backticks. Functions over inline blocks past ~10 lines.
+- **Errors.** Check command exit codes explicitly when \`set -e\` semantics aren't sufficient (e.g. pipes — use \`pipefail\`). \`trap\` for cleanup. Never \`|| true\` to silence errors without a comment explaining why.
+- **Args.** Use \`getopts\` or a small parser, not positional indexing past 2 args. \`--\` to separate flags from arguments when passing to other commands.
+- **Structure.** Top of script: shebang, \`set\` flags, \`readonly\` constants, then function definitions, then \`main\` call. One concern per script.
+- **Avoid.** \`eval\`. Word splitting / glob expansion by leaving variables unquoted. Mutating \`IFS\` in the middle of a script. Scripts longer than ~100 lines — switch to Python or Go.`,
+    terraform: `### Terraform / HCL
+
+- **Tooling.** Latest stable Terraform or OpenTofu. \`terraform fmt\`. \`tflint\` + \`tfsec\` (or \`checkov\`) in CI. Pinned provider versions in \`required_providers\`. Remote state with locking always.
+- **Structure.** Modules by infrastructure concern (\`network/\`, \`compute/\`, \`data/\`). \`main.tf\`, \`variables.tf\`, \`outputs.tf\`, \`versions.tf\` per module. No monolithic root module — environments compose modules.
+- **Variables.** Every variable has a \`type\` and a \`description\`. \`sensitive = true\` on secrets. Validate with \`validation\` blocks. No untyped \`any\` variables.
+- **State.** One state file per environment + concern. Never commit \`.tfstate\` or \`.tfvars\` with secrets to git. Use \`tfvars\` files per environment, kept out of public repos.
+- **Resources.** Explicit \`tags\` blocks on every resource that supports them. Lifecycle \`prevent_destroy = true\` on stateful infrastructure (databases, buckets) unless intentionally ephemeral.
+- **Avoid.** \`count\` for set-like collections — use \`for_each\` with a map. Hard-coded provider regions or account IDs (use variables). Implicit dependencies — declare \`depends_on\` when ordering matters. \`local-exec\` provisioners as a primary tool (use them only as a last resort).`,
+};
+//# sourceMappingURL=packs.js.map

package/dist/core/style-packs/packs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packs.js","sourceRoot":"","sources":["../../../src/core/style-packs/packs.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,KAAK,GAAyC;IACzD,UAAU,EAAE;;;;;;;;kPAQoO;IAEhP,UAAU,EAAE;;;;;;;;uIAQyH;IAErI,MAAM,EAAE;;;;;;;;wQAQ8P;IAEtQ,EAAE,EAAE;;;;;;;;2MAQqM;IAEzM,IAAI,EAAE;;;;;;;;gNAQwM;IAE9M,IAAI,EAAE;;;;;;;qMAO6L;IAEnM,MAAM,EAAE;;;;;;;;iKAQuJ;IAE/J,MAAM,EAAE;;;;;;;;kLAQwK;IAEhL,GAAG,EAAE;;;;;;;;6TAQsT;IAE3T,CAAC,EAAE;;;;;;;;6KAQwK;IAE3K,IAAI,EAAE;;;;;;;6OAOqO;IAE3O,GAAG,EAAE;;;;;;;uNAOgN;IAErN,KAAK,EAAE;;;;;;;;yMAQgM;IAEvM,KAAK,EAAE;;;;;;;sKAO6J;IAEpK,MAAM,EAAE;;;;;;;8NAOoN;IAE5N,OAAO,EAAE;;;;;;;6KAOkK;IAE3K,KAAK,EAAE;;;;;;;mOAO0N;IAEjO,MAAM,EAAE;;;;;;;2NAOiN;IAEzN,OAAO,EAAE;;;;;;;sPAO2O;IAEpP,IAAI,EAAE;;;;;;;2KAOmK;IAEzK,GAAG,EAAE;;;;;;;2MAOoM;IAEzM,GAAG,EAAE;;;;;;;uLAOgL;IAErL,GAAG,EAAE;;;;;;;2PAOoP;IAEzP,IAAI,EAAE;;;;;;;2LAOmL;IAEzL,SAAS,EAAE;;;;;;;iSAOoR;CAChS,CAAC"}

package/dist/core/verify-commands.d.ts

@@ -0,0 +1,35 @@
+import type { LanguageId } from "./language-detector.js";
+/**
+ * A verification command the agent should consider running after meaningful
+ * edits to satisfy the active style pack(s). These are *recommendations* —
+ * the agent picks the relevant ones for the change it just made.
+ *
+ * Detection is filesystem-only (manifest reads + script-name scans) — no
+ * command execution. Cheap to compute alongside language detection.
+ */
+export interface VerifyCommand {
+    /** Display label for the prompt (e.g. "lint", "typecheck", "test"). */
+    label: string;
+    /** The exact shell command, including the runner (pnpm/cargo/uv/etc.). */
+    command: string;
+    /** Which language pack this command verifies — for grouping in the prompt. */
+    language: LanguageId;
+}
+/**
+ * Compute the recommended verify commands for the active language set in `cwd`.
+ *
+ * Conservative by design: we only emit a command when its existence is
+ * essentially guaranteed by a manifest or convention. We never invent commands
+ * that might not exist. False positives here would train the agent to run
+ * commands that fail, which is worse than no recommendation at all.
+ */
+export declare function detectVerifyCommands(cwd: string, active: Set<LanguageId>): VerifyCommand[];
+/**
+ * Render the Verification section for the system prompt. Returns empty string
+ * when no commands were detected so the caller can skip the section entirely.
+ *
+ * Commands are grouped by language so the agent can quickly pick the relevant
+ * subset when its edit only touched one language.
+ */
+export declare function renderVerifySection(cmds: readonly VerifyCommand[]): string;
+//# sourceMappingURL=verify-commands.d.ts.map

package/dist/core/verify-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-commands.d.ts","sourceRoot":"","sources":["../../src/core/verify-commands.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,QAAQ,EAAE,UAAU,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,aAAa,EAAE,CAkI1F;AA2CD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,CAuB1E"}

package/dist/core/verify-commands.js

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Compute the recommended verify commands for the active language set in `cwd`.
+ *
+ * Conservative by design: we only emit a command when its existence is
+ * essentially guaranteed by a manifest or convention. We never invent commands
+ * that might not exist. False positives here would train the agent to run
+ * commands that fail, which is worse than no recommendation at all.
+ */
+export function detectVerifyCommands(cwd, active) {
+    const cmds = [];
+    // ── Node ecosystem (TS / JS) — read scripts from package.json
+    if (active.has("typescript") || active.has("javascript")) {
+        const scripts = readPackageJsonScripts(cwd);
+        if (scripts) {
+            const runner = detectNodeRunner(cwd);
+            const lang = active.has("typescript") ? "typescript" : "javascript";
+            // Common script names, in priority order — we pick the first match per category.
+            const pick = (...candidates) => {
+                for (const c of candidates) {
+                    if (typeof scripts[c] === "string")
+                        return c;
+                }
+                return null;
+            };
+            const lintScript = pick("lint", "lint:check");
+            if (lintScript)
+                cmds.push({ label: "lint", command: `${runner} ${lintScript}`, language: lang });
+            const typecheckScript = pick("typecheck", "check", "type-check");
+            if (typecheckScript)
+                cmds.push({ label: "typecheck", command: `${runner} ${typecheckScript}`, language: lang });
+            const formatScript = pick("format:check", "format-check", "prettier:check");
+            if (formatScript)
+                cmds.push({ label: "format", command: `${runner} ${formatScript}`, language: lang });
+            const testScript = pick("test", "test:unit");
+            if (testScript)
+                cmds.push({ label: "test", command: `${runner} ${testScript}`, language: lang });
+        }
+        else if (active.has("typescript") && fileExists(path.join(cwd, "tsconfig.json"))) {
+            // No package.json scripts — fall back to direct tsc invocation.
+            cmds.push({ label: "typecheck", command: "tsc --noEmit", language: "typescript" });
+        }
+    }
+    // ── Python — pyproject.toml conventions
+    if (active.has("python")) {
+        const pyproject = readFileSafe(path.join(cwd, "pyproject.toml"));
+        if (pyproject) {
+            if (/\[tool\.ruff/.test(pyproject)) {
+                cmds.push({ label: "lint", command: "ruff check .", language: "python" });
+                cmds.push({ label: "format", command: "ruff format --check .", language: "python" });
+            }
+            if (/\[tool\.pyright/.test(pyproject)) {
+                cmds.push({ label: "typecheck", command: "pyright", language: "python" });
+            }
+            else if (/\[tool\.mypy/.test(pyproject)) {
+                cmds.push({ label: "typecheck", command: "mypy .", language: "python" });
+            }
+            if (/\[tool\.pytest/.test(pyproject)) {
+                cmds.push({ label: "test", command: "pytest", language: "python" });
+            }
+        }
+    }
+    // ── Go — universally available toolchain
+    if (active.has("go")) {
+        cmds.push({ label: "vet", command: "go vet ./...", language: "go" });
+        cmds.push({ label: "format", command: "gofmt -l .", language: "go" });
+        cmds.push({ label: "test", command: "go test ./...", language: "go" });
+    }
+    // ── Rust — Cargo guarantees the toolchain
+    if (active.has("rust")) {
+        cmds.push({
+            label: "lint",
+            command: "cargo clippy --all-targets -- -D warnings",
+            language: "rust",
+        });
+        cmds.push({ label: "format", command: "cargo fmt --check", language: "rust" });
+        cmds.push({ label: "test", command: "cargo test", language: "rust" });
+    }
+    // ── Java — Gradle/Maven detection
+    if (active.has("java") || active.has("kotlin")) {
+        const lang = active.has("kotlin") ? "kotlin" : "java";
+        if (fileExists(path.join(cwd, "gradlew"))) {
+            cmds.push({ label: "build", command: "./gradlew build", language: lang });
+            cmds.push({ label: "test", command: "./gradlew test", language: lang });
+        }
+        else if (fileExists(path.join(cwd, "pom.xml"))) {
+            cmds.push({ label: "verify", command: "mvn verify", language: lang });
+        }
+    }
+    // ── C# — dotnet CLI
+    if (active.has("csharp")) {
+        cmds.push({ label: "build", command: "dotnet build --no-incremental", language: "csharp" });
+        cmds.push({
+            label: "format",
+            command: "dotnet format --verify-no-changes",
+            language: "csharp",
+        });
+        cmds.push({ label: "test", command: "dotnet test", language: "csharp" });
+    }
+    // ── Ruby — bundle + standardrb/rubocop conventions
+    if (active.has("ruby")) {
+        if (fileExists(path.join(cwd, "Gemfile"))) {
+            cmds.push({ label: "lint", command: "bundle exec rubocop", language: "ruby" });
+            cmds.push({ label: "test", command: "bundle exec rspec", language: "ruby" });
+        }
+    }
+    // ── Elixir — mix is canonical
+    if (active.has("elixir")) {
+        cmds.push({ label: "format", command: "mix format --check-formatted", language: "elixir" });
+        cmds.push({ label: "test", command: "mix test", language: "elixir" });
+    }
+    // ── PHP — composer + phpstan conventions
+    if (active.has("php")) {
+        if (fileExists(path.join(cwd, "composer.json"))) {
+            cmds.push({ label: "test", command: "composer test", language: "php" });
+        }
+    }
+    // ── Bash — shellcheck when scripts present
+    if (active.has("bash")) {
+        cmds.push({ label: "lint", command: "shellcheck **/*.sh", language: "bash" });
+    }
+    // ── Terraform / OpenTofu
+    if (active.has("terraform")) {
+        cmds.push({ label: "validate", command: "terraform validate", language: "terraform" });
+        cmds.push({
+            label: "format",
+            command: "terraform fmt -check -recursive",
+            language: "terraform",
+        });
+    }
+    return cmds;
+}
+// ── helpers ──────────────────────────────────────────────────────────────
+function fileExists(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readFileSafe(p) {
+    try {
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function readPackageJsonScripts(cwd) {
+    const raw = readFileSafe(path.join(cwd, "package.json"));
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed.scripts && typeof parsed.scripts === "object" ? parsed.scripts : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect the Node package runner: pnpm if `pnpm-lock.yaml` exists, yarn if
+ * `yarn.lock`, bun if `bun.lockb`, otherwise npm. Conservative default — npm
+ * is always available.
+ */
+function detectNodeRunner(cwd) {
+    if (fileExists(path.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fileExists(path.join(cwd, "yarn.lock")))
+        return "yarn";
+    if (fileExists(path.join(cwd, "bun.lockb")))
+        return "bun";
+    return "npm run";
+}
+/**
+ * Render the Verification section for the system prompt. Returns empty string
+ * when no commands were detected so the caller can skip the section entirely.
+ *
+ * Commands are grouped by language so the agent can quickly pick the relevant
+ * subset when its edit only touched one language.
+ */
+export function renderVerifySection(cmds) {
+    if (cmds.length === 0)
+        return "";
+    const byLang = new Map();
+    for (const c of cmds) {
+        const list = byLang.get(c.language);
+        if (list)
+            list.push(c);
+        else
+            byLang.set(c.language, [c]);
+    }
+    const sortedLangs = [...byLang.keys()].sort();
+    const lines = [];
+    for (const lang of sortedLangs) {
+        const list = byLang.get(lang);
+        const parts = list.map((c) => `\`${c.command}\` (${c.label})`).join(", ");
+        lines.push(`- **${lang}**: ${parts}`);
+    }
+    return (`## Verification\n\n` +
+        `After meaningful edits, run the relevant verification commands below to ` +
+        `confirm pack compliance. Pick only the commands matching the language(s) ` +
+        `you actually touched. If a command fails, fix the issues before reporting ` +
+        `the task complete \u2014 never claim success on unverified output.\n\n` +
+        lines.join("\n"));
+}
+//# sourceMappingURL=verify-commands.js.map

package/dist/core/verify-commands.js.map

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

package/dist/core/verify-commands.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=verify-commands.test.d.ts.map