dsh-better-copilot 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.3.0 — builtin review routing and temperature compatibility
+
+- Add volatile `autoReview.enabled`, `autoReview.model` and
+  `autoReview.reasoningEffort` settings. Builtin GitHub Copilot reviews default to
+  `gpt-6.1-terra`; DeepSeek Flash and non-Copilot routes retain their current
+  model. Omitted effort uses the selected model's adapter default.
+- Redispatch detached frozen auxiliary requests through the public LLM
+  waterfall, leaving conversation requests, review policy, permission state,
+  Session metadata and cancellation unchanged; dispose the listener on unload.
+- Remove the builtin Copilot reviewer's sampling parameter unless its model
+  positively advertises support. Map boolean account temperature capability
+  metadata into known/new catalog descriptors and strip explicitly unsupported
+  temperature on ordinary Copilot inference requests without model-name guesses.
+- Compose temperature and Gemini normalization in the existing wire transform;
+  a Gemini guard failure cannot discard a temperature fix. Add routing, effort
+  validation, metadata, protocol, lifecycle and publication regressions.
+
 ## 0.2.0 — read-only subagent route badge
 
 - Add a browser client half that shows an addressed subagent's effective model

package/README.md

@@ -12,6 +12,10 @@ One DeepSeek Harness plugin for GitHub Copilot:
   provider for the ordinary `web_search` tool.
 - **Gemini tool-declaration guard** — adds a missing root `properties` bucket to
   tool parameter schemas for configured Copilot routes.
+- **Builtin Auto review overrides** — selects the review model and effort without
+  changing the conversation model or the builtin authorization policy.
+- **Temperature compatibility** — omits unsupported sampling controls on the
+  Copilot wire, including the builtin reviewer's hard-coded zero.
 
 The plugin is a replacement for, and superset of, the earlier separate
 `dsh-copilot-catalog`, `dsh-copilot-search` and `dsh-copilot-tool-schema`
@@ -67,14 +71,55 @@ The bundle patch:
       providers: [github-copilot]
       families: [gemini]
       logFixes: false
+    autoReview:
+      enabled: true
+      # Optional: leave unset for Terra on Copilot, current model otherwise
+      # model: gpt-6.1-terra
+      # reasoningEffort: high
 ```
 
 `providers` is the pi-ai adapter's own schema, reused unchanged, so every
 provider setting behaves exactly as it does with the stock adapter. `search`
-configures the web-search provider; `toolSchema` configures the Gemini guard.
+configures the web-search provider; `toolSchema` configures the Gemini guard;
+`autoReview` configures the builtin review request only.
 
 Loader patches replace a row's `config` wholesale, not key by key: an override
-must restate `providers`, `search` and `toolSchema` together.
+must restate every non-default group it needs together. Omitted `search`,
+`toolSchema` and `autoReview` groups resolve their defaults.
+
+## Builtin Auto review
+
+`autoReview` applies only to requests marked `purpose: auto-review` by the builtin
+experimental Auto review plugin. It does not enable Auto review, select a
+permission preset, replace its policy or change normal conversation/subagent
+requests.
+
+- With no `autoReview.model`, GitHub Copilot reviews use `gpt-6.1-terra`.
+  DeepSeek Flash (`deepseek-v4-flash`) stays on Flash; other non-Copilot providers
+  retain their current model.
+- `autoReview.model` selects an exact model id on the current provider;
+  `autoReview.reasoningEffort` selects that model's exact effort id. Explicit
+  settings win over defaults, including on DeepSeek. Omitted effort uses the
+  selected model's adapter default, not the main agent's effort. A model change
+  drops any prior model's effort. Unsupported explicit efforts fail normally
+  before provider I/O, without clamping or silently switching models.
+- Settings are volatile: edits apply to the next review, not an in-flight review.
+  `autoReview.enabled: false` restores the builtin request's model and effort.
+
+The builtin reviewer hard-codes `temperature: 0`. Copilot review requests omit
+this parameter unless the selected catalog model positively advertises
+`compat.supportsTemperature: true`, so older GPT metadata lacking a temperature
+flag does not cause an unsupported-parameter error. This conservative rule is
+limited to the reviewer-owned control; it does not discard explicit sampling
+settings on ordinary requests with unknown support.
+
+For ordinary Copilot inference, account discovery maps boolean
+`capabilities.supports.temperature` into `compat.supportsTemperature`. The
+existing trusted wire transform strips `temperature` only for exact catalog
+models declaring `false`; supported and unknown metadata preserve the original
+body. No model-name or reasoning-capability heuristics are used. Temperature
+normalization remains active with wire identity disabled, and a Gemini guard
+failure cannot undo a successful temperature fix.
 
 ## Wire identity
 
@@ -99,7 +144,8 @@ dispatches. Inside the same refcounted, trusted-path-checked interceptor that
 carries the wire identity, it adds an empty root `properties` bucket to object
 tool schemas that lack one for a configured Copilot route and model family, and
 leaves every other byte of the request untouched. It never replaces an adapter or
-another plugin's settings, and a guard failure dispatches the original body.
+another plugin's settings, and a guard failure preserves the body after any
+successful temperature normalization.
 
 ## Subagent model badge (Web)
 

package/dist/auto-review.d.ts

@@ -0,0 +1,24 @@
+import { type GenerateOptions } from '@deepseek-ai/dsh-llm';
+import { type ModelCatalog, type PluginContext } from './catalog-types.js';
+import type { AutoReviewSettings } from './config.js';
+/** GitHub Copilot's default builtin authorization reviewer. */
+export declare const DEFAULT_REVIEW_MODEL = "gpt-6.1-terra";
+/** One live configuration snapshot for a review request. */
+export interface AutoReviewOverrides {
+    enabled: boolean;
+    model?: string;
+    reasoningEffort?: string;
+}
+/**
+ * Select only an auxiliary builtin review route. Never modify loop requests or
+ * caller-owned inputs, including the frozen request the builtin reviewer sends.
+ * Changing model drops a previous model's effort unless explicitly overridden.
+ */
+export declare function configureAutoReview(options: GenerateOptions<string>, settings: AutoReviewOverrides, catalog?: ModelCatalog): GenerateOptions<string>;
+/**
+ * The waterfall's next() accepts no replacement request. Redispatch a detached
+ * auxiliary request through the public LLM service instead, marking that exact
+ * object so the nested waterfall delegates once without rereading live settings.
+ * Cordis owns listener disposal; no review policy, permission or Session changes.
+ */
+export declare function installAutoReviewRouting(ctx: PluginContext, config: AutoReviewSettings, catalog: ModelCatalog): void;

package/dist/auto-review.js

@@ -0,0 +1,57 @@
+import { isAgentLoopRequest } from '@deepseek-ai/dsh-llm';
+import { asRecord } from './catalog-types.js';
+/** GitHub Copilot's default builtin authorization reviewer. */
+export const DEFAULT_REVIEW_MODEL = 'gpt-6.1-terra';
+/**
+ * Select only an auxiliary builtin review route. Never modify loop requests or
+ * caller-owned inputs, including the frozen request the builtin reviewer sends.
+ * Changing model drops a previous model's effort unless explicitly overridden.
+ */
+export function configureAutoReview(options, settings, catalog = {}) {
+    if (!settings.enabled || options.purpose !== 'auto-review' || isAgentLoopRequest(options))
+        return options;
+    const model = settings.model ?? (options.provider === 'github-copilot' && options.model !== 'deepseek-v4-flash'
+        ? DEFAULT_REVIEW_MODEL : options.model);
+    const reasoningEffort = settings.reasoningEffort ?? (model === options.model ? options.reasoningEffort : undefined);
+    const descriptor = Object.hasOwn(catalog, model) ? catalog[model] : undefined;
+    // The builtin's hard-coded zero is not a user inference setting. Require
+    // positive support for reviewer sampling; old SDK GPT catalogs omit this flag.
+    const omitTemperature = options.provider === 'github-copilot' && options.temperature !== undefined
+        && !(descriptor?.provider === 'github-copilot' && asRecord(descriptor.compat)?.supportsTemperature === true);
+    if (model === options.model && reasoningEffort === options.reasoningEffort && !omitTemperature)
+        return options;
+    const { reasoningEffort: _previous, temperature, ...rest } = options;
+    return Object.freeze({
+        ...rest, model,
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort: reasoningEffort }),
+        ...(omitTemperature || temperature === undefined ? {} : { temperature }),
+    });
+}
+/**
+ * The waterfall's next() accepts no replacement request. Redispatch a detached
+ * auxiliary request through the public LLM service instead, marking that exact
+ * object so the nested waterfall delegates once without rereading live settings.
+ * Cordis owns listener disposal; no review policy, permission or Session changes.
+ */
+export function installAutoReviewRouting(ctx, config, catalog) {
+    const routed = new WeakSet();
+    ctx.on('llm/stream', function (options, next) {
+        if (routed.has(options) || options.purpose !== 'auto-review' || isAgentLoopRequest(options))
+            return next();
+        const enabled = config.enabled.get();
+        if (!enabled)
+            return next();
+        const model = config.model.get();
+        const reasoningEffort = config.reasoningEffort.get();
+        const selected = configureAutoReview(options, {
+            enabled,
+            ...(model === undefined ? {} : { model }),
+            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+        }, catalog);
+        if (selected === options)
+            return next();
+        routed.add(selected);
+        // Purpose typing is owned by the optional builtin package, not a hard peer.
+        return this.stream(selected);
+    });
+}

package/dist/catalog.js

@@ -1,4 +1,5 @@
 import { asRecord } from './catalog-types.js';
+import { withCopilotTemperatureSupport } from './temperature.js';
 export const DEFAULT_COPILOT_BASE_URL = 'https://api.individual.githubcopilot.com';
 // Provider identity defaults match the supported pi-ai Copilot OAuth client.
 // These are protocol defaults, not metadata borrowed from a particular model.
@@ -165,7 +166,7 @@ export function selectAccountModels(response, catalog, { baseUrl = DEFAULT_COPIL
         // Own-property lookup prevents Object.prototype members becoming descriptors.
         const model = own(catalog, item.id) ?? createNewModel({ ...item, id: item.id }, headers, baseUrl);
         if (model) {
-            models[item.id] = model;
+            models[item.id] = withCopilotTemperatureSupport(model, supports?.temperature);
             unsupported.delete(item.id);
         }
         else {

package/dist/config.d.ts

@@ -30,11 +30,18 @@ export interface GuardConfigValue {
     families: Volatile<string[]>;
     logFixes: Volatile<boolean>;
 }
+/** Builtin Auto review routing; omitted leaves retain the model's adapter defaults. */
+export interface AutoReviewSettings {
+    enabled: Volatile<boolean>;
+    model: Volatile<string | undefined>;
+    reasoningEffort: Volatile<string | undefined>;
+}
 /** The one configuration object every capability reads from. */
 export interface BetterCopilotConfig {
     providers: ProvidersValue;
     search: SearchSettings;
     toolSchema: GuardConfigValue;
+    autoReview: AutoReviewSettings;
 }
 /** User-facing configuration: plain values, before volatile resolution. */
 export interface BetterCopilotConfigInput {
@@ -58,6 +65,11 @@ export interface BetterCopilotConfigInput {
         families?: string[];
         logFixes?: boolean;
     };
+    autoReview?: {
+        enabled?: boolean;
+        model?: string;
+        reasoningEffort?: string;
+    };
 }
 /**
  * The merged Config schema as the plugin and the Loader see it: callable, with a
@@ -115,6 +127,16 @@ export declare const GuardConfig: z<Schemastery.ObjectS<NoInfer<{
     families: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
     logFixes: z<boolean, boolean, "volatile-defined">;
 }>>, "plain">;
+/** Only the builtin reviewer is affected; exact model/effort ids are validated by LLM dispatch. */
+export declare const AutoReviewConfig: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    model: z<string, string, "volatile">;
+    reasoningEffort: z<string, string, "volatile">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    model: z<string, string, "volatile">;
+    reasoningEffort: z<string, string, "volatile">;
+}>>, "plain">;
 /**
  * The merged plugin's single configuration object: the adapter's provider map
  * plus one group per additional capability.

package/dist/config.js

@@ -23,6 +23,12 @@ export const GuardConfig = z.object({
     families: z.array(z.string()).default(['gemini']).volatile(),
     logFixes: z.boolean().default(false).volatile(),
 });
+/** Only the builtin reviewer is affected; exact model/effort ids are validated by LLM dispatch. */
+export const AutoReviewConfig = z.object({
+    enabled: z.boolean().default(true).volatile(),
+    model: z.string().min(1).volatile(),
+    reasoningEffort: z.string().min(1).volatile(),
+});
 /**
  * Reuse the pi-ai adapter's own provider profile schema instead of restating it.
  * A restated schema would silently drift from the adapter's defaults, validation
@@ -47,5 +53,6 @@ export function createConfig(originalConfig) {
         providers: providerProfileSchema(originalConfig),
         search: SearchConfig,
         toolSchema: GuardConfig,
+        autoReview: AutoReviewConfig,
     });
 }

package/dist/index.d.ts

@@ -7,6 +7,9 @@ export declare const apply: (ctx: PluginContext, config: BetterCopilotConfig) =>
 /** Preserved predecessor entry point: one read-only discovery with the merged runtime. */
 export declare const syncCopilotCatalog: (credentials?: CredentialReader, authOptions?: CopilotAuthOptions) => Promise<SyncResult>;
 export { DEFAULT_SEARCH_MODEL } from './config.js';
+export { configureAutoReview, DEFAULT_REVIEW_MODEL } from './auto-review.js';
+export type { AutoReviewOverrides } from './auto-review.js';
+export { normalizeCopilotTemperature } from './temperature.js';
 export { liveCost, selectAccountModels } from './catalog.js';
 export { DiscoveryError } from './discovery.js';
 export { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilotRequestTransform, isCopilotRequestPath, isTrustedCopilotUrl, rewriteCopilotRequestHeaders, wireIdentityMode, } from './identity.js';
@@ -16,7 +19,7 @@ export { COPILOT_SEARCH_PROVIDER_ID, CopilotSearchProvider } from './provider.js
 export { matchesRoute, normalizeToolSchemas, TOOL_SCHEMA_SKIPPED } from './schema.js';
 export { loadRuntime } from './runtime.js';
 export type { BetterCopilotRuntime, RuntimeOptions } from './runtime.js';
-export type { BetterCopilotConfig, BetterCopilotConfigSchema } from './config.js';
+export type { AutoReviewSettings, BetterCopilotConfig, BetterCopilotConfigSchema } from './config.js';
 export type { BetterCopilotDependencies, BetterCopilotPlugin } from './plugin.js';
 export type { AccountModelOptions } from './catalog.js';
 export type { NormalizeResult } from './schema.js';

package/dist/index.js

@@ -9,6 +9,8 @@ export const apply = (ctx, config) => plugin.apply(ctx, config);
 /** Preserved predecessor entry point: one read-only discovery with the merged runtime. */
 export const syncCopilotCatalog = (credentials, authOptions) => plugin.sync(credentials, authOptions);
 export { DEFAULT_SEARCH_MODEL } from './config.js';
+export { configureAutoReview, DEFAULT_REVIEW_MODEL } from './auto-review.js';
+export { normalizeCopilotTemperature } from './temperature.js';
 export { liveCost, selectAccountModels } from './catalog.js';
 export { DiscoveryError } from './discovery.js';
 export { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilotRequestTransform, isCopilotRequestPath, isTrustedCopilotUrl, rewriteCopilotRequestHeaders, wireIdentityMode, } from './identity.js';

package/dist/plugin.js

@@ -6,6 +6,8 @@ import { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilo
 import { CopilotSearchProvider } from './provider.js';
 import { TOOL_SCHEMA_SKIPPED } from './schema.js';
 import { guardCopilotRequestBody } from './guard.js';
+import { installAutoReviewRouting } from './auto-review.js';
+import { normalizeCopilotTemperature } from './temperature.js';
 export const name = 'better-copilot';
 /** Search and guard are optional capabilities; the adapter requires these two. */
 export const inject = ['llm', 'credentials'];
@@ -96,21 +98,28 @@ export function createPlugin(dependencies) {
             //    the defect. It is installed even when wire identity is opted out.
             contain('tool-schema guard', 'Gemini tool-schema normalization', () => {
                 const transform = ({ body }) => {
+                    let normalized;
+                    try {
+                        normalized = normalizeCopilotTemperature(body, dependencies.catalog);
+                    }
+                    catch {
+                        log('warn', 'better-copilot: skipped temperature normalization after an internal error');
+                    }
                     try {
                         const settings = guardSettings(config.toolSchema);
-                        const result = guardCopilotRequestBody(body, settings);
+                        const result = guardCopilotRequestBody(normalized ?? body, settings);
                         if (settings.logFixes) {
                             if (result.fixed.length > 0)
                                 log('info', 'better-copilot: added a properties bucket to %d tool schema(s) on the Copilot wire', result.fixed.length);
                             if (result.skipped.length > 0)
                                 log('warn', 'better-copilot: %s left %d tool schema(s) unchanged: %s', TOOL_SCHEMA_SKIPPED, result.skipped.length, JSON.stringify(result.skipped));
                         }
-                        return result.body;
+                        return result.body ?? normalized;
                     }
                     catch {
-                        // The request is delegated byte-identical; a guard failure never fails a call.
+                        // Guard failure never fails a call or discards a temperature fix.
                         log('warn', 'better-copilot: skipped one request after an internal error');
-                        return undefined;
+                        return normalized;
                     }
                 };
                 ctx.effect(() => installCopilotRequestTransform(transform), 'copilot: tool-schema wire normalization');
@@ -144,7 +153,11 @@ export function createPlugin(dependencies) {
                     });
                 });
             });
-            // 4. Catalog discovery, then the adapter itself. Only this step is fatal:
+            // 4. Builtin authorization reviewer routing, independently contained.
+            contain('auto-review routing', 'builtin review model overrides', () => {
+                installAutoReviewRouting(ctx, config.autoReview, dependencies.catalog);
+            });
+            // 5. Catalog discovery, then the adapter itself. Only this step is fatal:
             // without the adapter there is no Copilot inference route at all.
             try {
                 const credentials = ctx.get('credentials');

package/dist/temperature.d.ts

@@ -0,0 +1,19 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import { type ModelCatalog } from './catalog-types.js';
+/**
+ * Apply only an explicit boolean from capabilities.supports.temperature.
+ * OpenAI compat schemas do not yet declare this field, but the wire boundary
+ * reads the same metadata used natively by pi-ai's Anthropic serializer.
+ * Preserve descriptor identity when discovery has nothing new to say.
+ */
+export declare function withCopilotTemperatureSupport<T extends Model<Api>>(model: T, support: unknown): T;
+/**
+ * Omit an unsupported temperature after SDK serialization, for every request
+ * purpose (including auxiliary review). IDs are opaque and reasoning capability
+ * says nothing about temperature: only an exact catalog descriptor with explicit
+ * false compatibility metadata is sufficient to remove the field.
+ *
+ * Install through the existing trusted Copilot request transform, not as a
+ * separate interceptor. Undefined means the original body stays byte-identical.
+ */
+export declare function normalizeCopilotTemperature(body: string, catalog: ModelCatalog): string | undefined;

package/dist/temperature.js

@@ -0,0 +1,39 @@
+import { asRecord } from './catalog-types.js';
+/**
+ * Apply only an explicit boolean from capabilities.supports.temperature.
+ * OpenAI compat schemas do not yet declare this field, but the wire boundary
+ * reads the same metadata used natively by pi-ai's Anthropic serializer.
+ * Preserve descriptor identity when discovery has nothing new to say.
+ */
+export function withCopilotTemperatureSupport(model, support) {
+    if (typeof support !== 'boolean' || asRecord(model.compat)?.supportsTemperature === support)
+        return model;
+    return { ...model, compat: { ...model.compat, supportsTemperature: support } };
+}
+/**
+ * Omit an unsupported temperature after SDK serialization, for every request
+ * purpose (including auxiliary review). IDs are opaque and reasoning capability
+ * says nothing about temperature: only an exact catalog descriptor with explicit
+ * false compatibility metadata is sufficient to remove the field.
+ *
+ * Install through the existing trusted Copilot request transform, not as a
+ * separate interceptor. Undefined means the original body stays byte-identical.
+ */
+export function normalizeCopilotTemperature(body, catalog) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+    const request = asRecord(parsed);
+    if (!request || typeof request.model !== 'string' || !Object.hasOwn(request, 'temperature') ||
+        !Object.hasOwn(catalog, request.model))
+        return undefined;
+    const model = catalog[request.model];
+    if (model?.provider !== 'github-copilot' || asRecord(model.compat)?.supportsTemperature !== false)
+        return undefined;
+    delete request.temperature;
+    return JSON.stringify(request);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-better-copilot",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Account-aware GitHub Copilot model discovery, Copilot-compatible wire identity, native Responses web search and a Copilot Gemini tool-declaration guard in one DeepSeek Harness plugin.",
   "type": "module",
   "main": "./dist/index.js",
@@ -73,6 +73,7 @@
     "@deepseek-ai/cordis": "~4.1.0",
     "@deepseek-ai/dsh-credentials": "0.2.2-rc.1",
     "@deepseek-ai/dsh-launch-environment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
     "@deepseek-ai/dsh-llm-pi-ai": "0.2.2-rc.1",
     "@deepseek-ai/dsh-system-prompt": "0.2.2-rc.1",
     "@deepseek-ai/dsh-web": "0.2.2-rc.1",
@@ -84,6 +85,7 @@
     "@deepseek-ai/dsh-agent": "0.2.2-rc.1",
     "@deepseek-ai/dsh-credentials": "0.2.2-rc.1",
     "@deepseek-ai/dsh-launch-environment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
     "@deepseek-ai/dsh-llm-pi-ai": "0.2.2-rc.1",
     "@deepseek-ai/dsh-scope": "0.2.2-rc.1",
     "@deepseek-ai/dsh-session": "0.2.2-rc.1",
@@ -109,7 +111,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.client.json",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p test/tsconfig.json && tsc -p tsconfig.client.json --noEmit",
-    "test": "pnpm run build && node --import tsx --test test/catalog.test.ts test/discovery.test.ts test/identity.test.ts test/secrets.test.ts test/catalog-plugin.test.ts test/config.test.ts test/composition.test.ts test/auth.test.ts test/refresh.test.ts test/provider.test.ts test/responses.test.ts test/search-plugin.test.ts test/schema.test.ts test/guard.test.ts test/guard-plugin.test.ts test/patch.test.ts test/client.render.test.ts",
+    "test": "pnpm run build && node --import tsx --test test/catalog.test.ts test/discovery.test.ts test/identity.test.ts test/secrets.test.ts test/catalog-plugin.test.ts test/config.test.ts test/composition.test.ts test/auth.test.ts test/refresh.test.ts test/provider.test.ts test/responses.test.ts test/search-plugin.test.ts test/schema.test.ts test/guard.test.ts test/guard-plugin.test.ts test/patch.test.ts test/client.render.test.ts test/temperature.test.ts test/auto-review.test.ts",
     "test:integration": "pnpm run build && node --import tsx --test test/integration/nested-layout.test.ts test/integration/catalog-runtime.test.ts test/integration/enterprise.test.ts test/integration/identity-wire.test.ts test/integration/search-runtime.test.ts test/integration/guard-runtime.test.ts test/integration/wire.test.ts",
     "test:types": "pnpm run build && tsc -p test/types/tsconfig.json",
     "test:pack": "pnpm run build && tsx ../../scripts/check-pack.ts .",