pi-monofold 0.6.1 → 0.7.0

package/README.md

@@ -106,7 +106,7 @@ Example command flows: [docs/examples.md](./docs/examples.md).
 
 Default focus shortcut: `ctrl+shift+m` cycles Active Focus forward through `focusPresets` YAML order. No backward focus shortcut ships in the MVP.
 
-When Active Focus is set, Pi Monofold injects the active preset's `contextFiles` into each agent turn under **Focus Context Injection** and recomposes the manifest so active Workspace Targets are shown first while non-active targets are collapsed to one-line summaries. The MVP uses provisional context-injection caps that are intentionally temporary and exposed as constants for future tuning:
+When Active Focus is set, Pi Monofold injects the active preset's `contextFiles` into each agent turn under **Focus Context Injection** and recomposes the manifest so active Workspace Targets are shown first while non-active targets are collapsed to one-line summaries. Tag-based target inference in `monofold_read`, `monofold_write`, and `monofold_git` also prefers Workspace Targets that belong to the active preset when a tag query would otherwise match multiple candidates; explicit `targetId` / workspace name selectors and uniquely matching targets are unchanged. If multiple in-focus targets still tie, the existing workspace selection flow applies. The MVP uses provisional context-injection caps that are intentionally temporary and exposed as constants for future tuning:
 
 - Max **6** context files per active preset.
 - Max **6,000** characters per file, with `… [truncated]` appended when a file is cut.

package/focus-preset.ts

@@ -1,3 +1,4 @@
+import { parseFocusSkills, resetFocusSkillsWarningState } from "./focus-skills.js";
 import { assertKnownKeys, asStringArray, isRecord, uniqueStrings } from "./validation.js";
 
 export type FocusPresetTarget = {
@@ -8,13 +9,14 @@ export type FocusPreset = {
   id: string;
   label: string;
   targets: FocusPresetTarget[];
+  focusSkills?: string[];
 };
 
 export type FocusMatchableWorkspace = {
   tags: string[];
 };
 
-const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets"]);
+const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets", "focusSkills"]);
 const FOCUS_PRESET_TARGET_KEYS = new Set(["targetTags"]);
 
 /** Parses and validates focus preset configuration from YAML/JSON input. */
@@ -49,9 +51,15 @@ export function parseFocusPresets(value: unknown, label = "focusPresets"): Focus
       }
       targets.push({ targetTags });
     }
+    const focusSkills = parseFocusSkills(itemLabel, item.focusSkills);
     if (seenIds.has(item.id)) throw new Error(`${label} has duplicate preset id: ${item.id}`);
     seenIds.add(item.id);
-    presets.push({ id: item.id, label: item.label, targets });
+    presets.push({
+      id: item.id,
+      label: item.label,
+      targets,
+      ...(focusSkills !== undefined ? { focusSkills } : {}),
+    });
   }
   return presets;
 }
@@ -118,6 +126,7 @@ export function setActiveFocusPresetId(id: string, focusPresets: FocusPreset[] |
   }
   activeFocusPresetId = id;
   activeFocusInitialized = true;
+  resetFocusSkillsWarningState();
 }
 
 export type ActiveFocusPresetPosition = {
@@ -177,10 +186,40 @@ export function cycleActiveFocusPresetForward(focusPresets: FocusPreset[] | unde
 export function clearActiveFocusPresetId(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = true;
+  resetFocusSkillsWarningState();
 }
 
 /** Resets in-memory session state (for tests and process restart). */
 export function resetActiveFocusSessionState(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = false;
+  resetFocusSkillsWarningState();
+}
+
+export type TagBasedTargetInput = {
+  targetTags?: string[];
+  targetId?: string;
+  targetName?: string;
+  workspaceName?: string;
+  workspaceIndex?: number;
+};
+
+/** Returns true when workspace resolution relies on tag query without an explicit selector. */
+export function isTagBasedTargetInference(target: TagBasedTargetInput): boolean {
+  if (!target.targetTags?.length) return false;
+  if (target.targetId) return false;
+  const targetName = target.targetName ?? target.workspaceName;
+  if (targetName) return false;
+  if (target.workspaceIndex !== undefined) return false;
+  return true;
+}
+
+/** Narrows ambiguous tag matches to active-focus targets when at least one in-focus candidate exists. */
+export function biasMatchesTowardActiveFocus<T extends { targetId: string }>(
+  matches: T[],
+  activeTargetIds: ReadonlySet<string>,
+): T[] {
+  if (matches.length <= 1 || activeTargetIds.size === 0) return matches;
+  const inFocus = matches.filter((match) => activeTargetIds.has(match.targetId));
+  return inFocus.length > 0 ? inFocus : matches;
 }

package/focus-skills.ts

@@ -0,0 +1,106 @@
+import { formatSkillsForPrompt, type Skill } from "@earendil-works/pi-coding-agent";
+
+/** Max skills a single focus preset may auto-load (matches focus context file cap). */
+export const FOCUS_SKILLS_MAX_COUNT = 6;
+
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SKILLS_SECTION_PATTERN = /\n\nThe following skills provide[\s\S]*?<\/available_skills>/;
+
+/** Validates a focusSkills entry per Agent Skills name rules. */
+export function assertValidFocusSkillName(label: string, name: string): void {
+  if (name.trim() === "") {
+    throw new Error(`${label} must not contain empty skill names`);
+  }
+  if (name.length > 64) {
+    throw new Error(`${label} skill name exceeds 64 characters: ${name}`);
+  }
+  if (!SKILL_NAME_PATTERN.test(name)) {
+    throw new Error(`${label} skill name must use lowercase letters, digits, and hyphens only: ${name}`);
+  }
+}
+
+/** Parses and validates an optional focusSkills list from preset config. */
+export function parseFocusSkills(itemLabel: string, value: unknown): string[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`${itemLabel}.focusSkills must be an array of strings`);
+  }
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (let index = 0; index < value.length; index += 1) {
+    const raw = value[index]!;
+    const nameLabel = `${itemLabel}.focusSkills[${index}]`;
+    assertValidFocusSkillName(nameLabel, raw);
+    if (seen.has(raw)) {
+      throw new Error(`${itemLabel}.focusSkills has duplicate skill name: ${raw}`);
+    }
+    seen.add(raw);
+    names.push(raw);
+  }
+  if (names.length > FOCUS_SKILLS_MAX_COUNT) {
+    throw new Error(`${itemLabel}.focusSkills must contain at most ${FOCUS_SKILLS_MAX_COUNT} skill names`);
+  }
+  return names;
+}
+
+/** Removes Pi's default available-skills block from a system prompt, if present. */
+export function stripSkillsSectionFromSystemPrompt(systemPrompt: string): string {
+  return systemPrompt.replace(SKILLS_SECTION_PATTERN, "");
+}
+
+/** Resolves declared focus skill names against Pi's discovered skill inventory. */
+export function resolveFocusSkills(allSkills: Skill[] | undefined, focusSkillNames: string[] | undefined): Skill[] {
+  if (!focusSkillNames) return [];
+  const byName = new Map((allSkills ?? []).map((skill) => [skill.name, skill]));
+  return focusSkillNames.flatMap((name) => {
+    const skill = byName.get(name);
+    return skill ? [skill] : [];
+  });
+}
+
+/** Returns focusSkills names that are not present in the discovered inventory. */
+export function findMissingFocusSkills(focusSkillNames: string[] | undefined, allSkills: Skill[] | undefined): string[] {
+  if (!focusSkillNames?.length) return [];
+  const available = new Set((allSkills ?? []).map((skill) => skill.name));
+  return focusSkillNames.filter((name) => !available.has(name));
+}
+
+/** Replaces the default skills section with only focus-declared skills when configured. */
+export function applyFocusSkillsToSystemPrompt(
+  systemPrompt: string,
+  allSkills: Skill[] | undefined,
+  focusSkillNames: string[] | undefined,
+): string {
+  if (focusSkillNames === undefined) return systemPrompt;
+  const stripped = stripSkillsSectionFromSystemPrompt(systemPrompt);
+  const resolved = resolveFocusSkills(allSkills, focusSkillNames);
+  if (resolved.length === 0) return stripped;
+  return stripped + formatSkillsForPrompt(resolved);
+}
+
+let warnedFocusSkillsKey: string | null = null;
+
+/** Clears per-activation focus skill warning deduplication (for tests and focus changes). */
+export function resetFocusSkillsWarningState(): void {
+  warnedFocusSkillsKey = null;
+}
+
+/** Emits one actionable warning per focus activation for missing focusSkills names. */
+export function warnMissingFocusSkills(
+  presetId: string,
+  focusSkillNames: string[] | undefined,
+  allSkills: Skill[] | undefined,
+  warn: (message: string) => void,
+): void {
+  if (!focusSkillNames?.length) return;
+  const missing = findMissingFocusSkills(focusSkillNames, allSkills);
+  if (missing.length === 0) return;
+  const key = `${presetId}:${missing.join(",")}`;
+  if (warnedFocusSkillsKey === key) return;
+  warnedFocusSkillsKey = key;
+  for (const name of missing) {
+    warn(
+      `Focus preset "${presetId}" focusSkills: skill "${name}" was not found in Pi's discovered inventory. Check the skill name or install the package, then reload Pi.`,
+    );
+  }
+}

package/index.ts

@@ -12,12 +12,18 @@ import {
   findFocusPresetById,
   getActiveFocusPresetId,
   getActiveFocusPresetPosition,
+  biasMatchesTowardActiveFocus,
+  isTagBasedTargetInference,
   matchesFocusTarget,
   parseFocusPresets,
   setActiveFocusPresetByLabel,
   setActiveFocusPresetId,
   warnZeroTargetMatchesForPreset,
 } from "./focus-preset.js";
+import {
+  applyFocusSkillsToSystemPrompt,
+  warnMissingFocusSkills,
+} from "./focus-skills.js";
 import {
   buildMonofoldTree,
   readMonofoldFile,
@@ -917,9 +923,20 @@ function notifyNoFocusPresets(ctx: ExtensionContext | ExtensionCommandContext, p
   if (pi) sendCommandOutput(pi, "monofold:focus", message, { focusPresets: 0 });
 }
 
+function biasWorkspaceMatchesWithActiveFocus(loaded: LoadedConfig, matches: ResolvedWorkspace[]): ResolvedWorkspace[] {
+  const activePreset = getActiveFocusPreset(loaded);
+  if (!activePreset) return matches;
+  const activeTargetIds = new Set(getActiveFocusWorkspaces(loaded, activePreset).map(({ workspace }) => workspace.targetId));
+  return biasMatchesTowardActiveFocus(matches, activeTargetIds);
+}
+
 async function resolveWorkspace(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig, target: TargetInput): Promise<ResolvedWorkspace> {
-  const matches = loaded.workspaces.filter((workspace) => matchesTarget(workspace, target));
+  ensureActiveFocusInitialized(loaded.raw.focusPresets);
+  let matches = loaded.workspaces.filter((workspace) => matchesTarget(workspace, target));
   if (matches.length === 0) throw new Error(`No workspace matches target: ${JSON.stringify(target)}`);
+  if (matches.length > 1 && isTagBasedTargetInference(target)) {
+    matches = biasWorkspaceMatchesWithActiveFocus(loaded, matches);
+  }
   if (matches.length === 1) return matches[0];
   if (!ctx.hasUI) {
     throw new Error(`Multiple workspaces match target in non-interactive mode: ${matches.map(formatWorkspaceLabel).join(", ")}`);
@@ -1222,9 +1239,22 @@ export default function piMultiWorkspace(pi: ExtensionAPI) {
           "warning",
         );
       }
+      if (activePreset && ctx.hasUI) {
+        warnMissingFocusSkills(
+          activePreset.id,
+          activePreset.focusSkills,
+          _event.systemPromptOptions?.skills,
+          (message) => ctx.ui.notify(message, "warning"),
+        );
+      }
+      const baseSystemPrompt = applyFocusSkillsToSystemPrompt(
+        _event.systemPrompt,
+        _event.systemPromptOptions?.skills,
+        activePreset?.focusSkills,
+      );
       return {
         systemPrompt:
-          _event.systemPrompt +
+          baseSystemPrompt +
           `
 
 ## Pi Monofold

package/package.json

@@ -11,7 +11,7 @@
   },
   "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
   "type": "module",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "pi": {
     "extensions": [
       "./index.ts"
@@ -25,6 +25,7 @@
     "unknown-path-allows.ts",
     "file-read-preview.ts",
     "focus-preset.ts",
+    "focus-skills.ts",
     "monofold-read-ops.ts",
     "read-caps.ts",
     "validation.ts"