@nklisch/pi-enhanced 0.1.3 → 0.1.4

package/node_modules/@nklisch/pi-clearance/src/config/config-command-plans.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 
+import { DEFAULT_PROJECT_SCOPE_BEHAVIOR } from "./defaults.ts";
+import { isExactNonBashToolName } from "./gated-tools.ts";
 import type { JsonPatchOperation } from "../replay/proposal-schema.ts";
 import { isHighCostReviewerModel } from "../runtime/reviewer-model.ts";
 import type {
@@ -91,10 +93,12 @@ export function inferScopePreset(
     const fields = SCOPE_PRESET_FIELDS[preset];
     if (
       scope.safeHomeUseDefaults === fields.safeHomeUseDefaults &&
-      (scope.agentSupportUseDefaults ?? true) ===
+      (scope.agentSupportUseDefaults !== false) ===
         fields.agentSupportUseDefaults &&
-      (scope.homePathBehavior ?? "allow") === fields.homePathBehavior &&
-      (scope.sensitivePathBehavior ?? "review") ===
+      (scope.homePathBehavior ?? DEFAULT_PROJECT_SCOPE_BEHAVIOR.homePathBehavior) ===
+        fields.homePathBehavior &&
+      (scope.sensitivePathBehavior ??
+        DEFAULT_PROJECT_SCOPE_BEHAVIOR.sensitivePathBehavior) ===
         fields.sensitivePathBehavior &&
       scope.unknownPathBehavior === fields.unknownPathBehavior
     ) {
@@ -137,6 +141,10 @@ export type ReviewNoteDisplayCommandChange =
   | { readonly kind: "show-model-label"; readonly enabled: boolean }
   | { readonly kind: "accent"; readonly enabled: boolean };
 
+export type GatedToolCommandChange =
+  | { readonly kind: "add"; readonly toolName: string }
+  | { readonly kind: "remove"; readonly toolName: string };
+
 export type ReviewerCommandChange =
   | { readonly kind: "prompt-posture"; readonly promptPosture: string }
   | { readonly kind: "context-mode"; readonly contextMode: ReviewerContextMode }
@@ -181,6 +189,74 @@ export type PlanProjectScopeCommandChangeResult =
     }
   | { readonly ok: false; readonly reason: string };
 
+export function planGatedToolCommandChange(input: {
+  readonly change: GatedToolCommandChange;
+  readonly resolvedConfig: ResolvedConfig;
+}):
+  | { readonly ok: true; readonly plan: ConfigCommandPlan }
+  | { readonly ok: false; readonly reason: string } {
+  const toolName = input.change.toolName;
+  if (!isExactNonBashToolName(toolName)) {
+    return {
+      ok: false,
+      reason:
+        "gatedTools accepts exact non-Bash tool names only; wildcards, whitespace, and bash are not allowed",
+    };
+  }
+
+  const snapshots = input.resolvedConfig.sourceSnapshots;
+  if (snapshots === undefined) {
+    return {
+      ok: false,
+      reason:
+        "resolved config did not include source snapshots; reload config before planning a gated-tool write",
+    };
+  }
+
+  const before = cloneJsonish({
+    ...snapshots.global,
+    gatedTools: [...(snapshots.global.gatedTools ?? [])],
+  });
+  const after = cloneJsonish(before) as Mutable<GlobalConfig>;
+  const current = [...before.gatedTools];
+  const next =
+    input.change.kind === "add"
+      ? current.includes(toolName)
+        ? current
+        : [...current, toolName]
+      : current.filter((candidate) => candidate !== toolName);
+  after.gatedTools = next;
+  const patch = fieldPatch("/gatedTools", current, next);
+  const title =
+    input.change.kind === "add"
+      ? `Gate non-Bash tool ${toolName}`
+      : `Stop gating non-Bash tool ${toolName}`;
+  const planWithoutId = {
+    target: { kind: "global", path: snapshots.paths.globalConfigFile },
+    title,
+    summary:
+      patch.length === 0
+        ? `${title}; no config write is needed.`
+        : `${title}; only this exact tool name will use Clearance analysis and policy.`,
+    patch,
+    before,
+    after,
+    requiredAcknowledgementCodes: [],
+    warnings: [],
+  } satisfies Omit<ConfigCommandPlan, "id">;
+
+  return {
+    ok: true,
+    plan: {
+      id: deterministicPlanId({
+        gatedToolChange: input.change,
+        ...planWithoutId,
+      }),
+      ...planWithoutId,
+    },
+  };
+}
+
 export function planModeCommandChange(input: {
   readonly mode: ClearanceMode;
   readonly resolvedConfig: ResolvedConfig;

package/node_modules/@nklisch/pi-clearance/src/config/config-command-writer.ts

@@ -12,6 +12,10 @@ import type { TSchema } from "@sinclair/typebox";
 
 import type { JsonPatchOperation } from "../replay/proposal-schema.ts";
 import type { ResolvedConfig } from "./loader.ts";
+import {
+  type ConfigPersistenceKind,
+  serializeSparseConfigText,
+} from "./persistence.ts";
 import {
   type GlobalConfig,
   GlobalConfigSchema,
@@ -101,6 +105,7 @@ export type ConfigCommandApplyResult =
 interface AtomicConfigWriteInput {
   readonly planId: string;
   readonly targetPath: string;
+  readonly configKind: ConfigPersistenceKind;
   readonly value: GlobalConfig | ProjectOverlayConfig;
   readonly hadExistingFile: boolean;
   readonly reloadConfig: () => Promise<ResolvedConfig>;
@@ -184,6 +189,7 @@ export async function applyConfigCommandPlan(
   return await writeConfigTargetAndValidate({
     planId: plan.id,
     targetPath: plan.target.path,
+    configKind: plan.target.kind,
     value: patched.value,
     hadExistingFile: readResult.exists,
     reloadConfig: dependencies.reloadConfig,
@@ -207,7 +213,7 @@ export async function writeConfigTargetAndValidate(
     await mkdir(path.dirname(input.targetPath), { recursive: true });
     await writeFile(
       tempPath,
-      `${JSON.stringify(input.value, null, 2)}\n`,
+      serializeSparseConfigText(input.configKind, input.value),
       "utf8",
     );
     tempPresent = true;

package/node_modules/@nklisch/pi-clearance/src/config/defaults.ts

@@ -0,0 +1,42 @@
+/**
+ * User-visible defaults shared by schema normalization and status/read models.
+ * Keeping these values in one module prevents a new schema default from being
+ * mistaken for a customization by diagnostics.
+ */
+export const DEFAULT_REVIEWER_PROMPT_POSTURE = "reviewer.default" as const;
+export const DEFAULT_REVIEWER_CONTEXT_MODE = "recentContext" as const;
+
+export const DEFAULT_REVIEWER_TOKEN_BUDGET = {
+  window: "24h",
+  limit: null,
+} as const;
+
+export const DEFAULT_REVIEWER_RECENT_CONTEXT = {
+  decisionLimit: 25,
+  decisionWindow: "2h",
+  conversationTurns: 3,
+  userTurns: 5,
+  conversationCharLimit: 6000,
+} as const;
+
+export const DEFAULT_REVIEWER_ESCALATION = {
+  enabled: true,
+  denialLimit: 3,
+  window: "10m",
+} as const;
+
+export const DEFAULT_UNKNOWN_TOOL_POSTURE = "allow" as const;
+
+export const DEFAULT_PROJECT_SCOPE_BEHAVIOR = {
+  safeHomeUseDefaults: true,
+  agentSupportUseDefaults: true,
+  unknownPathBehavior: "review",
+  sensitivePathBehavior: "review",
+  homePathBehavior: "allow",
+} as const;
+
+export const DEFAULT_REVIEW_NOTE_DISPLAY = {
+  mode: "reason+accent",
+  showModelLabel: false,
+  accent: true,
+} as const;

package/node_modules/@nklisch/pi-clearance/src/config/gated-tools.ts

@@ -0,0 +1,7 @@
+/** Exact-name syntax for the global non-Bash Clearance opt-in list. */
+export const EXACT_NON_BASH_TOOL_NAME_PATTERN =
+  "^(?!bash$)[^\\s*?\\[\\]{}]+$" as const;
+
+export function isExactNonBashToolName(value: string): boolean {
+  return value.length > 0 && new RegExp(EXACT_NON_BASH_TOOL_NAME_PATTERN).test(value);
+}

package/node_modules/@nklisch/pi-clearance/src/config/loader.ts

@@ -3,6 +3,7 @@ import { homedir, tmpdir } from "node:os";
 import path from "node:path";
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { DecisionEffect } from "../policy/core.ts";
+import { DEFAULT_UNKNOWN_TOOL_POSTURE } from "./defaults.ts";
 import {
   isHighCostReviewerModel,
   parseModelSpec,
@@ -69,6 +70,7 @@ export interface ResolvedReviewerConfig {
     readonly decisionLimit: number;
     readonly decisionWindow: string;
     readonly conversationTurns: number;
+    readonly userTurns?: number;
     readonly conversationCharLimit: number;
   };
   readonly escalation: {
@@ -133,6 +135,8 @@ export interface ResolvedConfig {
    */
   readonly sourceSnapshots?: ResolvedConfigSourceSnapshots;
   readonly mode: ClearanceMode;
+  /** Exact non-Bash tool names explicitly opted into Clearance gating. */
+  readonly gatedTools?: readonly string[];
   readonly unknownToolPosture: DecisionEffect;
   readonly projectScope: ResolvedProjectScope;
   readonly packEnablement: ResolvedPackEnablement;
@@ -250,7 +254,9 @@ export async function loadConfig(
       repository: repositoryPolicy,
     },
     mode,
-    unknownToolPosture: globalConfig.unknownToolPosture ?? "allow",
+    gatedTools: [...globalConfig.gatedTools],
+    unknownToolPosture:
+      globalConfig.unknownToolPosture ?? DEFAULT_UNKNOWN_TOOL_POSTURE,
     projectScope: projectScopeResolution.scope,
     packEnablement,
     globalPacks: withPackSource(globalConfig.packs, "user-global"),

package/node_modules/@nklisch/pi-clearance/src/config/pack-enablement-writer.ts

@@ -113,6 +113,7 @@ export async function applyPackEnablementPlan(
   return await writeConfigTargetAndValidate({
     planId: plan.id,
     targetPath: plan.targetPath,
+    configKind: plan.request.scope,
     value: patched.value,
     hadExistingFile: readResult.exists,
     reloadConfig: dependencies.reloadConfig,

package/node_modules/@nklisch/pi-clearance/src/config/paths.ts

@@ -12,12 +12,18 @@ export interface ConfigPaths {
 }
 
 export function resolveUserConfigRoot(): string {
-  const home = homedir();
+  // Read the environment explicitly so isolated callers honor the process
+  // environment even when os.homedir() is cached.
+  const home = firstNonEmpty(
+    process.env.HOME,
+    process.env.USERPROFILE,
+  ) ?? homedir();
 
   switch (process.platform) {
     case "win32":
       return path.join(
-        process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"),
+        firstNonEmpty(process.env.LOCALAPPDATA) ??
+          path.join(home, "AppData", "Local"),
         "pi",
         "pi-clearance",
       );
@@ -31,13 +37,18 @@ export function resolveUserConfigRoot(): string {
       );
     default:
       return path.join(
-        process.env.XDG_CONFIG_HOME ?? path.join(home, ".config"),
+        firstNonEmpty(process.env.XDG_CONFIG_HOME) ??
+          path.join(home, ".config"),
         "pi",
         "pi-clearance",
       );
   }
 }
 
+function firstNonEmpty(...values: readonly (string | undefined)[]): string | undefined {
+  return values.find((value) => value !== undefined && value.length > 0);
+}
+
 export function projectKeyFor(cwd: string): string {
   const absolute = path.resolve(cwd);
   const hash = createHash("sha256").update(absolute).digest("hex").slice(0, 8);

package/node_modules/@nklisch/pi-clearance/src/config/persistence.ts

@@ -0,0 +1,135 @@
+import {
+  CONFIG_SCHEMA_VERSION,
+  type GlobalConfig,
+  GlobalConfigSchema,
+  normalizeConfig,
+  type ProjectOverlayConfig,
+  ProjectOverlaySchema,
+} from "./schema.ts";
+
+export type ConfigPersistenceKind = "global" | "project";
+export type NormalizedConfig = GlobalConfig | ProjectOverlayConfig;
+
+/** The only JSON shape emitted for user-owned Clearance config files. */
+export type SparseConfigDocument = Readonly<Record<string, unknown>> & {
+  readonly version: typeof CONFIG_SCHEMA_VERSION;
+};
+
+const OMIT = Symbol("omit-default");
+
+/**
+ * Serialize a schema-normalized runtime config without materializing defaults.
+ *
+ * Defaults are obtained by normalizing the schema's version-only seed rather
+ * than copied here. Objects are compacted recursively; arrays are semantic
+ * values and are retained as a whole whenever they differ from their default.
+ */
+export function serializeSparseConfig(
+  kind: ConfigPersistenceKind,
+  config: NormalizedConfig,
+): SparseConfigDocument {
+  const defaults = normalizedDefaults(kind);
+  const compacted = compactValue(config, defaults);
+  const document: Record<string, unknown> = {
+    version: config.version,
+  };
+
+  if (isRecord(compacted)) {
+    for (const [key, value] of Object.entries(compacted)) {
+      if (key !== "version") {
+        document[key] = value;
+      }
+    }
+  }
+
+  return canonicalize(document) as SparseConfigDocument;
+}
+
+/** Return the canonical on-disk representation for a normalized config. */
+export function serializeSparseConfigText(
+  kind: ConfigPersistenceKind,
+  config: NormalizedConfig,
+): string {
+  return `${JSON.stringify(serializeSparseConfig(kind, config), null, 2)}\n`;
+}
+
+function normalizedDefaults(kind: ConfigPersistenceKind): NormalizedConfig {
+  const schema = kind === "global" ? GlobalConfigSchema : ProjectOverlaySchema;
+  const result = normalizeConfig(schema, { version: CONFIG_SCHEMA_VERSION });
+  if (!result.ok) {
+    throw new Error(`failed to normalize ${kind} config defaults`);
+  }
+  return result.value;
+}
+
+function compactValue(value: unknown, defaults: unknown): unknown {
+  if (jsonEqual(value, defaults)) {
+    return OMIT;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneJsonish(entry));
+  }
+
+  if (isRecord(value)) {
+    const defaultRecord = isRecord(defaults) ? defaults : undefined;
+    const compacted: Record<string, unknown> = {};
+    for (const key of orderedKeys(Object.keys(value))) {
+      const child = compactValue(value[key], defaultRecord?.[key]);
+      if (child !== OMIT) {
+        compacted[key] = child;
+      }
+    }
+    return Object.keys(compacted).length === 0 ? OMIT : compacted;
+  }
+
+  return value;
+}
+
+function canonicalize(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+
+  if (isRecord(value)) {
+    const result: Record<string, unknown> = {};
+    for (const key of orderedKeys(Object.keys(value))) {
+      result[key] = canonicalize(value[key]);
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function orderedKeys(keys: readonly string[]): readonly string[] {
+  return [...keys].sort((left, right) => {
+    if (left === "version") return -1;
+    if (right === "version") return 1;
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+
+function jsonEqual(left: unknown, right: unknown): boolean {
+  return (
+    JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right))
+  );
+}
+
+function cloneJsonish<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneJsonish(entry)) as T;
+  }
+
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, cloneJsonish(entry)]),
+    ) as T;
+  }
+
+  return value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@nklisch/pi-clearance/src/config/schema.ts

@@ -1,6 +1,18 @@
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 
+import {
+  DEFAULT_PROJECT_SCOPE_BEHAVIOR,
+  DEFAULT_REVIEWER_CONTEXT_MODE,
+  DEFAULT_REVIEWER_ESCALATION,
+  DEFAULT_REVIEWER_PROMPT_POSTURE,
+  DEFAULT_REVIEWER_RECENT_CONTEXT,
+  DEFAULT_REVIEWER_TOKEN_BUDGET,
+  DEFAULT_REVIEW_NOTE_DISPLAY,
+  DEFAULT_UNKNOWN_TOOL_POSTURE,
+} from "./defaults.ts";
+import { EXACT_NON_BASH_TOOL_NAME_PATTERN } from "./gated-tools.ts";
+
 export const CONFIG_SCHEMA_VERSION = 1 as const;
 
 const STRICT_OBJECT_OPTIONS = { additionalProperties: false } as const;
@@ -148,9 +160,11 @@ export const PolicyPackSchema = Type.Object(
 
 export const ReviewNoteDisplaySchema = Type.Object(
   {
-    mode: reviewNoteModeLiteral({ default: "reason+accent" }),
-    showModelLabel: Type.Boolean({ default: false }),
-    accent: Type.Boolean({ default: true }),
+    mode: reviewNoteModeLiteral({ default: DEFAULT_REVIEW_NOTE_DISPLAY.mode }),
+    showModelLabel: Type.Boolean({
+      default: DEFAULT_REVIEW_NOTE_DISPLAY.showModelLabel,
+    }),
+    accent: Type.Boolean({ default: DEFAULT_REVIEW_NOTE_DISPLAY.accent }),
   },
   { ...STRICT_OBJECT_OPTIONS, default: {} },
 );
@@ -162,7 +176,7 @@ export const DisplayConfigSchema = Type.Object(
 
 export const ReviewerConfigSchema = Type.Object(
   {
-    promptPosture: Type.String({ default: "reviewer.default" }),
+    promptPosture: Type.String({ default: DEFAULT_REVIEWER_PROMPT_POSTURE }),
     promptAppends: Type.Array(Type.String(), { default: [] }),
     projectPromptAppends: Type.Array(Type.String(), { default: [] }),
     promptOverride: Type.Union([Type.String(), Type.Null()], { default: null }),
@@ -171,41 +185,58 @@ export const ReviewerConfigSchema = Type.Object(
     }),
     tokenBudget: Type.Object(
       {
-        window: Type.String({ default: "24h" }),
-        limit: Type.Union([Type.Number(), Type.Null()], { default: null }),
+        window: Type.String({ default: DEFAULT_REVIEWER_TOKEN_BUDGET.window }),
+        limit: Type.Union([Type.Number(), Type.Null()], {
+          default: DEFAULT_REVIEWER_TOKEN_BUDGET.limit,
+        }),
+      },
+      {
+        ...STRICT_OBJECT_OPTIONS,
+        default: DEFAULT_REVIEWER_TOKEN_BUDGET,
       },
-      { ...STRICT_OBJECT_OPTIONS, default: { window: "24h", limit: null } },
     ),
     contextMode: Type.Union(
       [Type.Literal("minimal"), Type.Literal("recentContext")],
-      { default: "recentContext" },
+      { default: DEFAULT_REVIEWER_CONTEXT_MODE },
     ),
     recentContext: Type.Object(
       {
-        decisionLimit: Type.Integer({ default: 25 }),
-        decisionWindow: Type.String({ default: "2h" }),
-        conversationTurns: Type.Integer({ default: 3 }),
-        conversationCharLimit: Type.Integer({ default: 6000 }),
+        decisionLimit: Type.Integer({
+          default: DEFAULT_REVIEWER_RECENT_CONTEXT.decisionLimit,
+        }),
+        decisionWindow: Type.String({
+          default: DEFAULT_REVIEWER_RECENT_CONTEXT.decisionWindow,
+        }),
+        conversationTurns: Type.Integer({
+          default: DEFAULT_REVIEWER_RECENT_CONTEXT.conversationTurns,
+        }),
+        userTurns: Type.Integer({
+          default: DEFAULT_REVIEWER_RECENT_CONTEXT.userTurns,
+        }),
+        conversationCharLimit: Type.Integer({
+          default: DEFAULT_REVIEWER_RECENT_CONTEXT.conversationCharLimit,
+        }),
       },
       {
         ...STRICT_OBJECT_OPTIONS,
         default: {
-          decisionLimit: 25,
-          decisionWindow: "2h",
-          conversationTurns: 3,
-          conversationCharLimit: 6000,
+          ...DEFAULT_REVIEWER_RECENT_CONTEXT,
         },
       },
     ),
     escalation: Type.Object(
       {
-        enabled: Type.Boolean({ default: true }),
-        denialLimit: Type.Integer({ default: 3 }),
-        window: Type.String({ default: "10m" }),
+        enabled: Type.Boolean({
+          default: DEFAULT_REVIEWER_ESCALATION.enabled,
+        }),
+        denialLimit: Type.Integer({
+          default: DEFAULT_REVIEWER_ESCALATION.denialLimit,
+        }),
+        window: Type.String({ default: DEFAULT_REVIEWER_ESCALATION.window }),
       },
       {
         ...STRICT_OBJECT_OPTIONS,
-        default: { enabled: true, denialLimit: 3, window: "10m" },
+        default: DEFAULT_REVIEWER_ESCALATION,
       },
     ),
   },
@@ -227,14 +258,25 @@ export const PackEnablementSchema = Type.Object(
   { ...STRICT_OBJECT_OPTIONS, default: {} },
 );
 
+const GatedToolName = Type.String({
+  minLength: 1,
+  // Tool opt-in is deliberately exact-name only. Keep the field a strict
+  // schema boundary so wildcard/future-tool consent cannot slip into config.
+  pattern: EXACT_NON_BASH_TOOL_NAME_PATTERN,
+});
+
 export const GlobalConfigSchema = Type.Object(
   {
     version: Type.Literal(CONFIG_SCHEMA_VERSION),
     mode: ClearanceModeLiteral,
+    gatedTools: Type.Array(GatedToolName, {
+      default: [],
+      uniqueItems: true,
+    }),
     unknownToolPosture: Type.Optional(
       Type.Union(
         [Type.Literal("allow"), Type.Literal("deny"), Type.Literal("review")],
-        { default: "allow" },
+        { default: DEFAULT_UNKNOWN_TOOL_POSTURE },
       ),
     ),
     packs: Type.Array(PolicyPackSchema, { default: [] }),
@@ -263,13 +305,19 @@ export const ProjectScopeSchema = Type.Object(
     tempDirectories: pathListSchema(),
     deniedDirectories: pathListSchema(),
     safeHomeDirectories: pathListSchema(),
-    safeHomeUseDefaults: Type.Boolean({ default: true }),
+    safeHomeUseDefaults: Type.Boolean({
+      default: DEFAULT_PROJECT_SCOPE_BEHAVIOR.safeHomeUseDefaults,
+    }),
     /** Optional custom Pi support roots; built-in roots remain enabled by default. */
     agentSupportDirectories: Type.Optional(pathListSchema()),
-    agentSupportUseDefaults: Type.Optional(Type.Boolean({ default: true })),
+    agentSupportUseDefaults: Type.Optional(
+      Type.Boolean({
+        default: DEFAULT_PROJECT_SCOPE_BEHAVIOR.agentSupportUseDefaults,
+      }),
+    ),
     unknownPathBehavior: Type.Union(
       [Type.Literal("review"), Type.Literal("deny")],
-      { default: "review" },
+      { default: DEFAULT_PROJECT_SCOPE_BEHAVIOR.unknownPathBehavior },
     ),
     /**
      * Behavior for paths the engine classifies as sensitive home
@@ -278,7 +326,7 @@ export const ProjectScopeSchema = Type.Object(
      */
     sensitivePathBehavior: Type.Union(
       [Type.Literal("review"), Type.Literal("deny")],
-      { default: "review" },
+      { default: DEFAULT_PROJECT_SCOPE_BEHAVIOR.sensitivePathBehavior },
     ),
     /**
      * `"review"` claws back baseline home-scope read auto-allows so any
@@ -286,7 +334,7 @@ export const ProjectScopeSchema = Type.Object(
      */
     homePathBehavior: Type.Union(
       [Type.Literal("allow"), Type.Literal("review")],
-      { default: "allow" },
+      { default: DEFAULT_PROJECT_SCOPE_BEHAVIOR.homePathBehavior },
     ),
   },
   { ...STRICT_OBJECT_OPTIONS, default: {} },

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCase.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AdversarialCaseCategory } from "./AdversarialCaseCategory.ts";
 import type { AdversarialCaseExpectation } from "./AdversarialCaseExpectation.ts";

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCaseCategory.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 export type AdversarialCaseCategory =

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCaseExpectation.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 export type AdversarialCaseExpectation =

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCaseResult.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AdversarialCaseCategory } from "./AdversarialCaseCategory.ts";
 import type { AdversarialCaseExpectation } from "./AdversarialCaseExpectation.ts";

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCaseResultOutcome.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 export type AdversarialCaseResultOutcome =

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialCaseSource.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 export type AdversarialCaseSource =

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialValidationReport.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AdversarialCase } from "./AdversarialCase.ts";
 import type { AdversarialCaseResult } from "./AdversarialCaseResult.ts";

package/node_modules/@nklisch/pi-clearance/src/contracts/AdversarialValidationStatus.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 export type AdversarialValidationStatus = "not-run" | "passed" | "failed";

package/node_modules/@nklisch/pi-clearance/src/contracts/BashBlock.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { BashListOperator } from "./BashListOperator.ts";
 import type { BashPipeline } from "./BashPipeline.ts";

package/node_modules/@nklisch/pi-clearance/src/contracts/BashCommandShape.ts

@@ -1,4 +1,4 @@
-// @generated by ts-rs; do not edit. Run `pnpm contracts:generate`.
+// @generated by ts-rs; do not edit. Run `npm run contracts:generate`.
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { BashBlock } from "./BashBlock.ts";
 import type { BashPathFacts } from "./BashPathFacts.ts";