@mrclrchtr/supi-skills 4.10.0 → 6.0.0

package/README.md

@@ -35,6 +35,25 @@ Use `Tab` to switch between project and global scope. Project settings inherit g
 
 Skills that an extension adds only at runtime support Enabled and Model invocation disabled. PI does not provide a persistent load setting for these resources. PI exposes only the active source after a name collision, so disabling a static winner can reveal a runtime source after reload. The refreshed row then shows the runtime limitation.
 
+## Config shape
+
+SuPi stores Model Invocation overrides as per-skill records in the SuPi config:
+
+```json
+{
+  "skills": {
+    "$schemaVersion": 2,
+    "review": {
+      "modelInvocation": "disabled"
+    }
+  }
+}
+```
+
+Use `enabled` or `disabled` as the stored value. An absent record or field inherits the source default, global value, or project value. Skill Load remains in PI's native settings. SuPi adds the schema marker so a skill named `modelInvocation` can use an ordinary record.
+
+Older versions stored boolean values in `skills.modelInvocation`. SuPi reads that format and migrates valid entries on the next settings write. Invalid values remain preserved, marked as invalid, and produce a warning until they are repaired. A conflicting legacy fallback is kept under `$legacyModelInvocation` until the invalid record is repaired.
+
 ## Input shortcut
 
 `$skill-name` expands to `/skill:skill-name`. Skill-only autocomplete is active while the cursor is in a `$...` token.

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -28,6 +28,7 @@ pnpm add @mrclrchtr/supi-core
 - `loadSupiConfig()` — merged config with resolution order `defaults <- global <- project`
 - `loadSupiConfigForScope()` — load one scope at a time for settings UIs
 - `writeSupiConfig()` — persist values
+- `replaceSupiConfigSection()` — replace one nested section while preserving other sections
 - `removeSupiConfigKey()` — remove a key or override
 
 Config file locations:
@@ -49,6 +50,7 @@ Config file locations:
 
 - context-provider registry for `/supi-context`
 - debug-event registry and monotonic phase timers for producers that want shared debug capture
+- optional Debug Operation IDs for exact, directly owned public Tool-call correlation; ambient events stay uncorrelated
 - settings registry used by `/supi-settings`
 
 ### Project and session helpers

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "4.10.0",
+  "version": "6.0.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {
@@ -53,7 +53,7 @@
     "./api": "./src/api.ts",
     "./config": "./src/config.ts",
     "./context": "./src/context.ts",
-    "./debug": "./src/debug-registry.ts",
+    "./debug": "./src/debug.ts",
     "./evidence-badge": "./src/evidence-badge.ts",
     "./footer-registry": "./src/footer-registry.ts",
     "./llm": "./src/llm.ts",

package/node_modules/@mrclrchtr/supi-core/src/api.ts

@@ -11,7 +11,7 @@ export * from "./config.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./context.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
-export * from "./debug-registry.ts";
+export * from "./debug.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./evidence-badge.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel

package/node_modules/@mrclrchtr/supi-core/src/config/config.ts

@@ -148,6 +148,37 @@ export function writeSupiConfig(
   fs.writeFileSync(configPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
 }
 
+/**
+ * Replace one complete config section while preserving other sections.
+ *
+ * This is useful for nested settings that must remove stale keys as part of
+ * one update. An empty section is removed from the config file.
+ */
+export function replaceSupiConfigSection(
+  loc: SupiConfigLocation,
+  value: Record<string, unknown>,
+  options?: SupiConfigOptions,
+): void {
+  const configPath = getSupiConfigPath(loc.scope, loc.cwd, options);
+  const existing = readJsonFile(configPath) ?? {};
+
+  if (Object.keys(value).length > 0) existing[loc.section] = value;
+  else delete existing[loc.section];
+
+  const content = Object.keys(existing).length > 0 ? `${JSON.stringify(existing, null, 2)}\n` : "";
+  if (content) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, content, "utf-8");
+    return;
+  }
+
+  try {
+    fs.unlinkSync(configPath);
+  } catch {
+    // File may not exist.
+  }
+}
+
 /**
  * Remove a key from a config section.
  * Used by `interval default` to remove the project override.

package/node_modules/@mrclrchtr/supi-core/src/config.ts

@@ -1,10 +1,12 @@
 // supi-core config domain — config loading.
 export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
 export {
+  getSupiConfigPath,
   loadSupiConfig,
   loadSupiConfigForScope,
   loadSupiConfigSectionForScope,
   readJsonFile,
   removeSupiConfigKey,
+  replaceSupiConfigSection,
   writeSupiConfig,
 } from "./config/config.ts";

package/node_modules/@mrclrchtr/supi-core/src/debug-registry.ts

@@ -4,9 +4,6 @@
 // supi-debug extension owns policy/configuration and exposes events through a
 // command/tool while this module stays dependency-free for producers.
 
-// biome-ignore lint/performance/noReExportAll: preserve the stable debug domain entry point
-export * from "./debug-timing.ts";
-
 export type DebugLevel = "debug" | "info" | "warning" | "error";
 export type DebugAgentAccess = "off" | "sanitized" | "raw";
 export interface DebugRegistryConfig {
@@ -25,6 +22,8 @@ export const DEBUG_REGISTRY_DEFAULTS: DebugRegistryConfig = {
 };
 
 export interface DebugEventInput {
+  /** Opaque identity for events directly owned by one public Tool call. */
+  operationId?: string;
   source: string;
   level: DebugLevel;
   category: string;
@@ -42,6 +41,8 @@ export interface DebugEvent extends DebugEventInput {
 }
 
 export interface DebugEventQuery {
+  /** Match one exact Debug Operation ID. */
+  operationId?: string;
   source?: string;
   level?: DebugLevel;
   category?: string;
@@ -53,6 +54,7 @@ export interface DebugEventQuery {
 export interface DebugEventView {
   id: number;
   timestamp: number;
+  operationId?: string;
   source: string;
   level: DebugLevel;
   category: string;
@@ -84,6 +86,7 @@ interface DebugRegistryState {
 }
 
 const REGISTRY_KEY = Symbol.for("@mrclrchtr/supi-core/debug-registry");
+const DEBUG_OPERATION_ID_RE = /^op-[A-Za-z0-9_-]{21}[AQgw]$/;
 const SECRET_KEY_RE = /(?:token|password|passwd|secret|api[_-]?key|authorization|credential)/i;
 const ENV_SECRET_RE =
   /\b([A-Za-z0-9_]*(?:token|password|passwd|secret|api[_-]?key|authorization|credential)[A-Za-z0-9_]*)=(?:'[^']*'|"[^"]*"|\S+)/gi;
@@ -135,11 +138,17 @@ export function isDebugLevel(value: unknown): value is DebugLevel {
   return value === "debug" || value === "info" || value === "warning" || value === "error";
 }
 
-/** Match a debug event against the supported source, level, and category filters. */
+/** Return whether a value has the exact 16-byte base64url Debug Operation ID form. */
+export function isDebugOperationId(value: unknown): value is string {
+  return typeof value === "string" && DEBUG_OPERATION_ID_RE.test(value);
+}
+
+/** Match a debug event against the supported exact filters. */
 export function matchesDebugEventQuery(
-  event: Pick<DebugEventView, "source" | "level" | "category">,
-  query: Pick<DebugEventQuery, "source" | "level" | "category">,
+  event: Pick<DebugEventView, "operationId" | "source" | "level" | "category">,
+  query: Pick<DebugEventQuery, "operationId" | "source" | "level" | "category">,
 ): boolean {
+  if (query.operationId && event.operationId !== query.operationId) return false;
   if (query.source && event.source !== query.source) return false;
   if (query.level && event.level !== query.level) return false;
   if (query.category && event.category !== query.category) return false;
@@ -197,6 +206,7 @@ function toSanitizedView(event: DebugEvent): DebugEventView {
   return {
     id: event.id,
     timestamp: event.timestamp,
+    operationId: event.operationId,
     source: event.source,
     level: event.level,
     category: event.category,
@@ -216,6 +226,9 @@ export function subscribeDebugEvents(listener: DebugEventListener): () => void {
 /** Record a session-local debug event if debugging is enabled. */
 export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
   const state = getState();
+  if (input.operationId !== undefined && !isDebugOperationId(input.operationId)) {
+    return null;
+  }
   if (!state.config.enabled) {
     return null;
   }

package/node_modules/@mrclrchtr/supi-core/src/debug.ts

@@ -0,0 +1,9 @@
+// Debug domain entry for `@mrclrchtr/supi-core/debug`.
+//
+// Kept separate from debug-registry.ts so debug-timing.ts can import the
+// registry without creating an import cycle through the barrel re-export.
+
+// biome-ignore lint/performance/noReExportAll: preserve the stable debug domain entry point
+export * from "./debug-registry.ts";
+// biome-ignore lint/performance/noReExportAll: preserve the stable debug domain entry point
+export * from "./debug-timing.ts";

package/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -11,7 +11,7 @@ export * from "./config.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./context.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
-export * from "./debug-registry.ts";
+export * from "./debug.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./footer-registry.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel

package/node_modules/@mrclrchtr/supi-core/src/settings/settings-registry.ts

@@ -41,7 +41,10 @@ export interface SettingsApplyResult {
  */
 export interface SettingsModule {
   id: string;
+  /** Human-readable section label shown in the UI. */
   label: string;
+  /** Optional label that groups this module within its section. */
+  subsection?: string;
   read(context: SettingsContext): Promise<SettingsSnapshot>;
   apply(request: SettingsActionRequest): Promise<SettingsApplyResult>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-skills",
-  "version": "4.10.0",
+  "version": "6.0.0",
   "description": "Scoped skill controls and skill input shortcuts for PI",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "4.10.0"
+    "@mrclrchtr/supi-core": "6.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/skill-model-invocation-config.ts

@@ -0,0 +1,373 @@
+import {
+  loadSupiConfigSectionForScope,
+  replaceSupiConfigSection,
+} from "@mrclrchtr/supi-core/config";
+import type { SettingsScope, ValueSource } from "@mrclrchtr/supi-core/settings";
+
+const CONFIG_SECTION = "skills";
+const MODEL_INVOCATION_KEY = "modelInvocation";
+const SCHEMA_VERSION_KEY = "$schemaVersion";
+const SCHEMA_VERSION = 2;
+const LEGACY_MODEL_INVOCATION_KEY = "$legacyModelInvocation";
+const INVALID_MODEL_INVOCATION_KEY = "$invalidModelInvocation";
+
+/** Persisted Model Invocation states for one skill. */
+export type ModelInvocationState = "enabled" | "disabled";
+
+type SkillConfigRecord = Record<string, unknown>;
+
+interface InvocationOptions {
+  name: string;
+  scope: SettingsScope;
+  cwd: string;
+  homeDir?: string;
+}
+
+interface ResolveInvocationOptions extends InvocationOptions {
+  sourceDefault: boolean;
+  projectTrusted: boolean;
+}
+
+interface ParsedInvocationConfig {
+  section: SkillConfigRecord;
+  records: Map<string, SkillConfigRecord>;
+  invalidRecords: Map<string, unknown>;
+  legacy: Map<string, unknown>;
+  legacyMapKeys: Set<string>;
+  invalidNames: Set<string>;
+}
+
+interface InvocationConfigSet {
+  global: ParsedInvocationConfig;
+  project?: ParsedInvocationConfig;
+}
+
+function isRecord(value: unknown): value is SkillConfigRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasOwn(value: object, key: string): boolean {
+  return Object.hasOwn(value, key);
+}
+
+function setOwn(target: SkillConfigRecord, key: string, value: unknown): void {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+}
+
+function cloneRecord(value: SkillConfigRecord): SkillConfigRecord {
+  return Object.fromEntries(Object.entries(value));
+}
+
+function isModelInvocationState(value: unknown): value is ModelInvocationState {
+  return value === "enabled" || value === "disabled";
+}
+
+function legacyState(value: unknown): ModelInvocationState | undefined {
+  if (typeof value !== "boolean") return undefined;
+  return value ? "disabled" : "enabled";
+}
+
+/** An unversioned `modelInvocation` object is always the old boolean map. */
+function isLegacyMapCandidate(value: unknown): value is SkillConfigRecord {
+  return isRecord(value);
+}
+
+function addInvalidName(config: ParsedInvocationConfig, name: string): void {
+  config.invalidNames.add(name);
+}
+
+function parseLegacyMap(
+  config: ParsedInvocationConfig,
+  key: string,
+  value: SkillConfigRecord,
+): void {
+  config.legacyMapKeys.add(key);
+  for (const [skillName, skillValue] of Object.entries(value)) {
+    config.legacy.set(skillName, skillValue);
+    if (legacyState(skillValue) === undefined) addInvalidName(config, skillName);
+  }
+}
+
+function parseRecord(config: ParsedInvocationConfig, name: string, value: unknown): void {
+  if (!isRecord(value)) {
+    config.invalidRecords.set(name, value);
+    addInvalidName(config, name);
+    return;
+  }
+
+  const record = cloneRecord(value);
+  config.records.set(name, record);
+  const state = record[MODEL_INVOCATION_KEY];
+  if (
+    hasOwn(record, MODEL_INVOCATION_KEY) &&
+    (!isModelInvocationState(state) || record[INVALID_MODEL_INVOCATION_KEY] === true)
+  ) {
+    addInvalidName(config, name);
+  }
+}
+
+function parseInvocationConfig(section: Record<string, unknown> | null): ParsedInvocationConfig {
+  const parsed: ParsedInvocationConfig = {
+    section: section ? cloneRecord(section) : {},
+    records: new Map(),
+    invalidRecords: new Map(),
+    legacy: new Map(),
+    legacyMapKeys: new Set(),
+    invalidNames: new Set(),
+  };
+  const versioned = parsed.section[SCHEMA_VERSION_KEY] === SCHEMA_VERSION;
+
+  for (const [name, value] of Object.entries(parsed.section)) {
+    if (name === SCHEMA_VERSION_KEY) continue;
+    if (name === LEGACY_MODEL_INVOCATION_KEY) {
+      if (isRecord(value)) parseLegacyMap(parsed, name, value);
+      else addInvalidName(parsed, name);
+      continue;
+    }
+    if (name === MODEL_INVOCATION_KEY && !versioned && isLegacyMapCandidate(value)) {
+      parseLegacyMap(parsed, name, value);
+      continue;
+    }
+    parseRecord(parsed, name, value);
+  }
+
+  return parsed;
+}
+
+function readInvocationConfig(
+  scope: SettingsScope,
+  cwd: string,
+  homeDir?: string,
+): ParsedInvocationConfig {
+  return parseInvocationConfig(
+    loadSupiConfigSectionForScope(CONFIG_SECTION, cwd, { scope, homeDir }),
+  );
+}
+
+function readInvocationConfigs(
+  cwd: string,
+  projectTrusted: boolean,
+  homeDir?: string,
+): InvocationConfigSet {
+  return {
+    global: readInvocationConfig("global", cwd, homeDir),
+    ...(projectTrusted ? { project: readInvocationConfig("project", cwd, homeDir) } : {}),
+  };
+}
+
+function stateFromConfig(
+  config: ParsedInvocationConfig,
+  name: string,
+): ModelInvocationState | undefined {
+  const record = config.records.get(name);
+  if (
+    record &&
+    record[INVALID_MODEL_INVOCATION_KEY] !== true &&
+    isModelInvocationState(record[MODEL_INVOCATION_KEY])
+  ) {
+    return record[MODEL_INVOCATION_KEY];
+  }
+  return legacyState(config.legacy.get(name));
+}
+
+interface ResolveFromConfigsOptions {
+  name: string;
+  sourceDefault: boolean;
+  scope: SettingsScope;
+  projectTrusted: boolean;
+  configs: InvocationConfigSet;
+}
+
+function resolveFromConfigs({
+  name,
+  sourceDefault,
+  scope,
+  projectTrusted,
+  configs,
+}: ResolveFromConfigsOptions): { disabled: boolean; source: ValueSource } {
+  if (scope === "project" && projectTrusted && configs.project) {
+    const projectState = stateFromConfig(configs.project, name);
+    if (projectState) return { disabled: projectState === "disabled", source: "project" };
+  }
+
+  const globalState = stateFromConfig(configs.global, name);
+  if (globalState) return { disabled: globalState === "disabled", source: "global" };
+
+  return { disabled: sourceDefault, source: "default" };
+}
+
+/** Resolve a scoped Model Invocation preference without reading untrusted project config. */
+export function resolveInvocation({
+  name,
+  sourceDefault,
+  scope,
+  cwd,
+  projectTrusted,
+  homeDir,
+}: ResolveInvocationOptions): { disabled: boolean; source: ValueSource } {
+  return resolveFromConfigs({
+    name,
+    sourceDefault,
+    scope,
+    projectTrusted,
+    configs: readInvocationConfigs(cwd, projectTrusted && scope === "project", homeDir),
+  });
+}
+
+function removeOwn(target: SkillConfigRecord, key: string): void {
+  if (hasOwn(target, key)) delete target[key];
+}
+
+function setInvalidState(record: SkillConfigRecord, value: unknown): void {
+  setOwn(record, MODEL_INVOCATION_KEY, value);
+  setOwn(record, INVALID_MODEL_INVOCATION_KEY, true);
+}
+
+function removeLegacyKeys(section: SkillConfigRecord, keys: ReadonlySet<string>): void {
+  for (const key of keys) removeOwn(section, key);
+}
+
+interface MigrateLegacyEntryOptions {
+  config: ParsedInvocationConfig;
+  name: string;
+  value: unknown;
+  nextSection: SkillConfigRecord;
+  remainingLegacy: SkillConfigRecord;
+}
+
+function migrateLegacyEntry({
+  config,
+  name,
+  value,
+  nextSection,
+  remainingLegacy,
+}: MigrateLegacyEntryOptions): void {
+  const record = config.records.get(name);
+  const oldState = legacyState(value);
+  if (config.invalidRecords.has(name)) {
+    setOwn(remainingLegacy, name, value);
+    return;
+  }
+
+  if (!record) {
+    const migrated: SkillConfigRecord = {};
+    if (oldState) setOwn(migrated, MODEL_INVOCATION_KEY, oldState);
+    else setInvalidState(migrated, value);
+    config.records.set(name, migrated);
+    setOwn(nextSection, name, migrated);
+    return;
+  }
+
+  if (!hasOwn(record, MODEL_INVOCATION_KEY)) {
+    if (oldState) setOwn(record, MODEL_INVOCATION_KEY, oldState);
+    else setInvalidState(record, value);
+    setOwn(nextSection, name, record);
+    return;
+  }
+
+  const currentValid =
+    record[INVALID_MODEL_INVOCATION_KEY] !== true &&
+    isModelInvocationState(record[MODEL_INVOCATION_KEY]);
+  if (!currentValid || !oldState) setOwn(remainingLegacy, name, value);
+}
+
+function migrateLegacyEntries(
+  config: ParsedInvocationConfig,
+  nextSection: SkillConfigRecord,
+): SkillConfigRecord {
+  const remainingLegacy: SkillConfigRecord = {};
+  removeLegacyKeys(nextSection, config.legacyMapKeys);
+  for (const [name, value] of config.legacy) {
+    migrateLegacyEntry({ config, name, value, nextSection, remainingLegacy });
+  }
+  return remainingLegacy;
+}
+
+interface ApplyInvocationChangeOptions {
+  name: string;
+  disabled: boolean | undefined;
+  records: Map<string, SkillConfigRecord>;
+  invalidRecords: Map<string, unknown>;
+  nextSection: SkillConfigRecord;
+  remainingLegacy: SkillConfigRecord;
+}
+
+function applyInvocationChange({
+  name,
+  disabled,
+  records,
+  invalidRecords,
+  nextSection,
+  remainingLegacy,
+}: ApplyInvocationChangeOptions): void {
+  if (disabled === undefined) {
+    const record = records.get(name);
+    if (record) {
+      removeOwn(record, MODEL_INVOCATION_KEY);
+      removeOwn(record, INVALID_MODEL_INVOCATION_KEY);
+      if (Object.keys(record).length === 0) removeOwn(nextSection, name);
+      else setOwn(nextSection, name, record);
+    } else if (invalidRecords.has(name)) {
+      removeOwn(nextSection, name);
+    }
+    removeOwn(remainingLegacy, name);
+    return;
+  }
+
+  const record = records.get(name) ?? {};
+  setOwn(record, MODEL_INVOCATION_KEY, disabled ? "disabled" : "enabled");
+  removeOwn(record, INVALID_MODEL_INVOCATION_KEY);
+  setOwn(nextSection, name, record);
+  removeOwn(remainingLegacy, name);
+}
+
+/**
+ * Set or remove one scoped Model Invocation preference.
+ *
+ * Writes use per-skill records. Legacy booleans are converted. Invalid legacy
+ * values use a marker so their raw value stays invalid and visible to repair.
+ */
+export function persistInvocation({
+  name,
+  disabled,
+  scope,
+  cwd,
+  homeDir,
+}: InvocationOptions & { disabled: boolean | undefined }): void {
+  const config = readInvocationConfig(scope, cwd, homeDir);
+  const nextSection = cloneRecord(config.section);
+  setOwn(nextSection, SCHEMA_VERSION_KEY, SCHEMA_VERSION);
+  const remainingLegacy = migrateLegacyEntries(config, nextSection);
+  applyInvocationChange({
+    name,
+    disabled,
+    records: config.records,
+    invalidRecords: config.invalidRecords,
+    nextSection,
+    remainingLegacy,
+  });
+
+  if (Object.keys(remainingLegacy).length > 0) {
+    setOwn(nextSection, LEGACY_MODEL_INVOCATION_KEY, remainingLegacy);
+  }
+  replaceSupiConfigSection({ section: CONFIG_SECTION, scope, cwd }, nextSection, { homeDir });
+}
+
+/** Return invalid skill names grouped by config scope for warning displays. */
+export function readInvalidInvocationConfigNames(
+  cwd: string,
+  projectTrusted: boolean,
+  homeDir?: string,
+): Array<{ scope: SettingsScope; names: string[] }> {
+  const configs = readInvocationConfigs(cwd, projectTrusted, homeDir);
+  return (Object.entries(configs) as Array<[SettingsScope, ParsedInvocationConfig | undefined]>)
+    .filter((entry): entry is [SettingsScope, ParsedInvocationConfig] =>
+      Boolean(entry[1] && entry[1].invalidNames.size > 0),
+    )
+    .map(([scope, config]) => ({ scope, names: [...config.invalidNames] }));
+}

package/src/skill-model-invocation-warnings.ts

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSupiConfigPath } from "@mrclrchtr/supi-core/config";
+import { readInvalidInvocationConfigNames } from "./skill-model-invocation-config.ts";
+
+const INVALID_CONFIG_WARNING_KEY = Symbol.for(
+  "@mrclrchtr/supi-skills/invalid-model-invocation-config",
+);
+
+function warningSessionId(ctx: ExtensionContext): string {
+  const sessionManager = ctx.sessionManager as ExtensionContext["sessionManager"] & {
+    getSessionId?: () => string;
+  };
+  return typeof sessionManager.getSessionId === "function"
+    ? sessionManager.getSessionId()
+    : `cwd:${ctx.cwd}`;
+}
+
+/** Show invalid config warnings once for each scope file in one PI session. */
+export function notifyInvocationConfigWarnings(ctx: ExtensionContext, homeDir?: string): void {
+  const invalidConfigs = readInvalidInvocationConfigNames(ctx.cwd, ctx.isProjectTrusted(), homeDir);
+  const globalRecord = globalThis as Record<symbol, Set<string> | undefined>;
+  const warned = globalRecord[INVALID_CONFIG_WARNING_KEY] ?? new Set<string>();
+  globalRecord[INVALID_CONFIG_WARNING_KEY] = warned;
+  const sessionId = warningSessionId(ctx);
+
+  for (const { scope, names } of invalidConfigs) {
+    const configPath = getSupiConfigPath(scope, ctx.cwd, { homeDir });
+    const warningKey = `${sessionId}\0${configPath}`;
+    if (warned.has(warningKey)) continue;
+    warned.add(warningKey);
+
+    const skillNames = names.sort((left, right) => left.localeCompare(right)).join(", ");
+    const message = `Invalid skills config in ${configPath} for ${skillNames}. Invalid Model Invocation values are ignored.`;
+    if (ctx.hasUI !== false) ctx.ui.notify(message, "warning");
+    else {
+      // biome-ignore lint/suspicious/noConsole: config warnings need a non-UI fallback
+      console.warn(`[supi-skills] ${message}`);
+    }
+  }
+}

package/src/skill-model-invocation.ts

@@ -2,100 +2,16 @@ import {
   type BuildSystemPromptOptions,
   formatSkillsForPrompt,
 } from "@earendil-works/pi-coding-agent";
-import {
-  loadSupiConfigSectionForScope,
-  removeSupiConfigKey,
-  writeSupiConfig,
-} from "@mrclrchtr/supi-core/config";
-import type { SettingsScope, ValueSource } from "@mrclrchtr/supi-core/settings";
+import { resolveInvocation } from "./skill-model-invocation-config.ts";
 
-const CONFIG_SECTION = "skills";
-const MODEL_INVOCATION_KEY = "modelInvocation";
+export type { ModelInvocationState } from "./skill-model-invocation-config.ts";
+export { persistInvocation, resolveInvocation } from "./skill-model-invocation-config.ts";
+export { notifyInvocationConfigWarnings } from "./skill-model-invocation-warnings.ts";
 
 export const ENABLED = "Enabled";
 export const MODEL_DISABLED = "Model invocation disabled";
 export const DISABLED = "Disabled";
 
-function invocationMap(
-  scope: SettingsScope,
-  cwd: string,
-  homeDir?: string,
-): Record<string, boolean> {
-  const section = loadSupiConfigSectionForScope(CONFIG_SECTION, cwd, { scope, homeDir });
-  const value = section?.[MODEL_INVOCATION_KEY];
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return Object.fromEntries(
-    Object.entries(value).filter(
-      (entry): entry is [string, boolean] => typeof entry[1] === "boolean",
-    ),
-  );
-}
-
-interface InvocationOptions {
-  name: string;
-  scope: SettingsScope;
-  cwd: string;
-  homeDir?: string;
-}
-
-interface ResolveInvocationOptions extends InvocationOptions {
-  sourceDefault: boolean;
-  projectTrusted: boolean;
-}
-
-/** Resolve a scoped model-invocation preference without reading untrusted project config. */
-export function resolveInvocation({
-  name,
-  sourceDefault,
-  scope,
-  cwd,
-  projectTrusted,
-  homeDir,
-}: ResolveInvocationOptions): { disabled: boolean; source: ValueSource } {
-  if (scope === "project" && projectTrusted) {
-    const project = invocationMap("project", cwd, homeDir);
-    if (Object.hasOwn(project, name)) {
-      return { disabled: project[name] ?? sourceDefault, source: "project" };
-    }
-  }
-  const global = invocationMap("global", cwd, homeDir);
-  if (Object.hasOwn(global, name)) {
-    return { disabled: global[name] ?? sourceDefault, source: "global" };
-  }
-  return { disabled: sourceDefault, source: "default" };
-}
-
-/** Set or remove one scoped model-invocation preference. */
-export function persistInvocation({
-  name,
-  disabled,
-  scope,
-  cwd,
-  homeDir,
-}: InvocationOptions & { disabled: boolean | undefined }): void {
-  const values = invocationMap(scope, cwd, homeDir);
-  if (disabled === undefined) delete values[name];
-  else {
-    Object.defineProperty(values, name, {
-      value: disabled,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  }
-  if (Object.keys(values).length === 0) {
-    removeSupiConfigKey({ section: CONFIG_SECTION, scope, cwd }, MODEL_INVOCATION_KEY, {
-      homeDir,
-    });
-    return;
-  }
-  writeSupiConfig(
-    { section: CONFIG_SECTION, scope, cwd },
-    { [MODEL_INVOCATION_KEY]: values },
-    { homeDir },
-  );
-}
-
 /** Replace PI's generated skill block with the effective scoped invocation state. */
 export function applyPromptOverrides({
   options,

package/src/skill-settings.ts

@@ -33,17 +33,16 @@ import {
   DISABLED,
   ENABLED,
   MODEL_DISABLED,
+  notifyInvocationConfigWarnings,
   persistInvocation,
   resolveInvocation,
 } from "./skill-model-invocation.ts";
 
 const SETTINGS_SECTION_ID = "skills";
-
 interface SkillSettingsOptions {
   agentDir?: string;
   homeDir?: string;
 }
-
 interface SkillSettingsControllerOptions {
   cwd: string;
   agentDir: string;
@@ -56,14 +55,12 @@ interface SkillSettingsControllerOptions {
 function recordResources(record: SkillRecord): ResolvedResource[] {
   return record.sources.flatMap((source) => (source.resource ? [source.resource] : []));
 }
-
 function isLoaded(record: SkillRecord): boolean {
   return (
     record.activeSkill !== undefined ||
     record.sources.some((source) => source.runtime || source.resource?.enabled)
   );
 }
-
 function canDisable(record: SkillRecord): boolean {
   return record.sources.length > 0 && record.sources.every((source) => !source.runtime);
 }
@@ -370,9 +367,10 @@ function createSkillSettingsModule(options: SkillSettingsOptions): SettingsModul
   return {
     id: SETTINGS_SECTION_ID,
     label: "Skills",
-    read: async (context) => ({
-      rows: (await getController(context)).read(context.scope, context.ctx),
-    }),
+    read: async (context) => {
+      if (context.ctx) notifyInvocationConfigWarnings(context.ctx, options.homeDir);
+      return { rows: (await getController(context)).read(context.scope, context.ctx) };
+    },
     apply: async (request) =>
       (await getController(request)).apply(
         request.scope,
@@ -388,6 +386,7 @@ export default function skillSettings(pi: ExtensionAPI, options: SkillSettingsOp
   registerSettings(pi, createSkillSettingsModule(options));
 
   pi.on("before_agent_start", (event, ctx) => {
+    notifyInvocationConfigWarnings(ctx, options.homeDir);
     const systemPrompt = applyPromptOverrides({
       options: event.systemPromptOptions,
       systemPrompt: event.systemPrompt,