pi-monofold 0.6.2 → 0.8.0

package/focus-preset.ts

@@ -1,3 +1,5 @@
+import { type MonofoldRouteType, parseDefaultRouteOverride } from "./focus-route-override.js";
+import { parseFocusSkills, resetFocusSkillsWarningState } from "./focus-skills.js";
 import { assertKnownKeys, asStringArray, isRecord, uniqueStrings } from "./validation.js";
 
 export type FocusPresetTarget = {
@@ -8,13 +10,15 @@ export type FocusPreset = {
   id: string;
   label: string;
   targets: FocusPresetTarget[];
+  focusSkills?: string[];
+  defaultRouteOverride?: MonofoldRouteType;
 };
 
 export type FocusMatchableWorkspace = {
   tags: string[];
 };
 
-const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets"]);
+const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets", "focusSkills", "defaultRouteOverride"]);
 const FOCUS_PRESET_TARGET_KEYS = new Set(["targetTags"]);
 
 /** Parses and validates focus preset configuration from YAML/JSON input. */
@@ -49,9 +53,17 @@ export function parseFocusPresets(value: unknown, label = "focusPresets"): Focus
       }
       targets.push({ targetTags });
     }
+    const focusSkills = parseFocusSkills(itemLabel, item.focusSkills);
+    const defaultRouteOverride = parseDefaultRouteOverride(itemLabel, item.defaultRouteOverride);
     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 } : {}),
+      ...(defaultRouteOverride !== undefined ? { defaultRouteOverride } : {}),
+    });
   }
   return presets;
 }
@@ -118,6 +130,7 @@ export function setActiveFocusPresetId(id: string, focusPresets: FocusPreset[] |
   }
   activeFocusPresetId = id;
   activeFocusInitialized = true;
+  resetFocusSkillsWarningState();
 }
 
 export type ActiveFocusPresetPosition = {
@@ -177,12 +190,14 @@ 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 = {

package/focus-route-override.ts

@@ -0,0 +1,44 @@
+/** Monofold route types available for routed Markdown writes. */
+export const MONOFOLD_ROUTE_TYPES = [
+  "default",
+  "prd",
+  "design",
+  "progress",
+  "issue",
+  "research",
+  "decision",
+] as const;
+
+export type MonofoldRouteType = (typeof MONOFOLD_ROUTE_TYPES)[number];
+
+const ROUTE_TYPE_SET = new Set<string>(MONOFOLD_ROUTE_TYPES);
+
+/** Validates a route type string and returns the typed value. */
+export function assertMonofoldRouteType(label: string, value: string): MonofoldRouteType {
+  if (!ROUTE_TYPE_SET.has(value)) {
+    throw new Error(
+      `${label} must be one of: ${MONOFOLD_ROUTE_TYPES.join(", ")} (got: ${value})`,
+    );
+  }
+  return value as MonofoldRouteType;
+}
+
+/** Parses an optional defaultRouteOverride from preset config. */
+export function parseDefaultRouteOverride(itemLabel: string, value: unknown): MonofoldRouteType | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${itemLabel}.defaultRouteOverride must be a non-empty string`);
+  }
+  return assertMonofoldRouteType(`${itemLabel}.defaultRouteOverride`, value.trim());
+}
+
+/** Resolves the effective write route: explicit selection wins over Focus default, then "default". */
+export function resolveWriteRouteType(
+  explicitRoute: string | undefined,
+  defaultRouteOverride: MonofoldRouteType | undefined,
+): MonofoldRouteType {
+  if (explicitRoute !== undefined && explicitRoute !== "") {
+    return assertMonofoldRouteType("routeType", explicitRoute);
+  }
+  return defaultRouteOverride ?? "default";
+}

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

@@ -20,6 +20,14 @@ import {
   setActiveFocusPresetId,
   warnZeroTargetMatchesForPreset,
 } from "./focus-preset.js";
+import {
+  resolveWriteRouteType,
+  type MonofoldRouteType,
+} from "./focus-route-override.js";
+import {
+  applyFocusSkillsToSystemPrompt,
+  warnMissingFocusSkills,
+} from "./focus-skills.js";
 import {
   buildMonofoldTree,
   readMonofoldFile,
@@ -37,7 +45,7 @@ import { assertKnownKeys, asStringArray, isRecord, uniqueStrings } from "./valid
 type CapabilityTag = "read" | "writeDocs" | "editCode" | "runCommands" | "git";
 type LegacyCapabilityTag = CapabilityTag | "gitCommit" | "gitPush";
 type IntentCategory = "Explore" | "Write" | "Config" | "Git";
-type RouteType = "default" | "prd" | "design" | "progress" | "issue" | "research" | "decision";
+type RouteType = MonofoldRouteType;
 
 type RouteConfig = {
   path: string;
@@ -888,7 +896,11 @@ function sendCommandError(pi: ExtensionAPI, command: string, error: unknown, usa
 }
 
 function formatFocusStatus(position: ActiveFocusPresetPosition): string {
-  return `focus: ${position.preset.label} (${position.index + 1}/${position.total}) ${FOCUS_CYCLE_SHORTCUT}`;
+  const base = `focus: ${position.preset.label} (${position.index + 1}/${position.total}) ${FOCUS_CYCLE_SHORTCUT}`;
+  if (position.preset.defaultRouteOverride) {
+    return `${base} route:${position.preset.defaultRouteOverride}`;
+  }
+  return base;
 }
 
 function updateFocusStatus(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig): void {
@@ -1022,6 +1034,9 @@ async function buildManifest(loaded: LoadedConfig): Promise<string> {
     const activeTargetIds = new Set(activeWorkspaces.map(({ workspace }) => workspace.targetId));
     if (activeWorkspaces.length > 0) {
       lines.push(`Active Focus: ${activePreset.label} (${activePreset.id})`);
+      if (activePreset.defaultRouteOverride) {
+        lines.push(`Default write route override: ${activePreset.defaultRouteOverride} (explicit routeType/--route still wins)`);
+      }
       for (const { workspace } of activeWorkspaces) {
         lines.push(await buildFullWorkspaceManifestEntry(workspace, " (active)"));
       }
@@ -1042,6 +1057,9 @@ async function buildManifest(loaded: LoadedConfig): Promise<string> {
 async function buildFocusContextInjection(loaded: LoadedConfig, preset: FocusPreset): Promise<FocusContextInjection> {
   const activeWorkspaces = getActiveFocusWorkspaces(loaded, preset);
   const lines = ["## Focus Context Injection", "", `Active Focus: ${preset.label} (${preset.id})`];
+  if (preset.defaultRouteOverride) {
+    lines.push(`Default write route override: ${preset.defaultRouteOverride} (explicit routeType/--route still wins)`);
+  }
   const notices: string[] = [];
   const seenFiles = new Set<string>();
   let injectedFileCount = 0;
@@ -1235,9 +1253,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
@@ -1369,7 +1400,7 @@ ${focusInjection.text}` : ""}
     label: "Workspace Write",
     description: "Write a Markdown document to a routed Workspace destination using routeType, title, body, filename, and metadata.",
     parameters: Type.Object({
-      routeType: Type.String({ description: "default, prd, design, progress, issue, research, or decision" }),
+      routeType: Type.Optional(Type.String({ description: "default, prd, design, progress, issue, research, or decision; omitted uses active Focus defaultRouteOverride or default" })),
       title: Type.String(),
       body: Type.String(),
       filename: Type.Optional(Type.String()),
@@ -1380,9 +1411,9 @@ ${focusInjection.text}` : ""}
       workspaceName: Type.Optional(Type.String()),
     }),
     async execute(_id, params, _signal, _onUpdate, ctx) {
-      const routeType = params.routeType as RouteType;
-      if (!ROUTE_TYPES.includes(routeType)) throw new Error(`Unknown routeType: ${params.routeType}`);
       const loaded = await loadConfig(ctx.cwd);
+      const activePreset = getActiveFocusPreset(loaded);
+      const routeType = resolveWriteRouteType(params.routeType, activePreset?.defaultRouteOverride);
       const workspace = await resolveWorkspace(ctx, loaded, {
         targetTags: params.targetTags,
         targetName: params.targetName,
@@ -1596,14 +1627,15 @@ ${focusInjection.text}` : ""}
   const writeCommand = async (args: string, ctx: ExtensionCommandContext) => {
     try {
       const parsed = parseCommandArgs(args);
-      const routeType = (stringFlag(parsed.flags, "route", "r") ?? parsed.positional[0] ?? "default") as RouteType;
-      if (!ROUTE_TYPES.includes(routeType)) throw new Error(`Unknown routeType: ${routeType}`);
       const title = stringFlag(parsed.flags, "title", "t");
       const body = stringFlag(parsed.flags, "body", "b");
       if (!title) throw new Error("--title is required");
       if (!body) throw new Error("--body is required");
 
       const loaded = await loadConfig(ctx.cwd);
+      const activePreset = getActiveFocusPreset(loaded);
+      const explicitRoute = stringFlag(parsed.flags, "route", "r") ?? parsed.positional[0];
+      const routeType = resolveWriteRouteType(explicitRoute, activePreset?.defaultRouteOverride);
       const workspace = await resolveWorkspace(ctx, loaded, commandTarget(parsed.flags, ["writeDocs"]));
       const route = workspace.normalizedRoutes[routeType] ?? workspace.normalizedRoutes.default;
       if (!route) throw new Error(`Workspace has no route for ${routeType} and no default route`);

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.2",
+  "version": "0.8.0",
   "pi": {
     "extensions": [
       "./index.ts"
@@ -25,6 +25,8 @@
     "unknown-path-allows.ts",
     "file-read-preview.ts",
     "focus-preset.ts",
+    "focus-route-override.ts",
+    "focus-skills.ts",
     "monofold-read-ops.ts",
     "read-caps.ts",
     "validation.ts"