pi-monofold 0.7.0 → 0.9.0

package/README.md

@@ -86,7 +86,7 @@ pi -e npm:pi-monofold
 1. Install the extension (see [Install](#install)).
 2. In your control repository, create `.pi/monofold.yaml` with at least one workspace entry (or run `/monofold:init`).
 3. Start Pi in the control repository and run `/monofold:explore show the project workspaces`.
-4. Use `/monofold:focus` or `ctrl+shift+m` to switch focus presets when `focusPresets` are configured.
+4. Use `/monofold:focus`, `ctrl+shift+m`, or `shift+ctrl+f` to switch focus presets when `focusPresets` are configured.
 5. Use `/monofold:write` for routed Markdown outputs and `/monofold:git` for guarded git workflows.
 
 Example command flows: [docs/examples.md](./docs/examples.md).
@@ -100,11 +100,12 @@ Example command flows: [docs/examples.md](./docs/examples.md).
 | `/monofold:config` | Add or change workspaces and project workspaces |
 | `/monofold:git` | Run guarded git status, commit, push, or commit+push |
 | `/monofold:focus` | Select the active focus preset from a TUI list |
+| `/monofold:focus-prev` | Cycle Active Focus backward through `focusPresets` YAML order |
 | `/monofold:guide` | Interactive guide for common flows |
 | `/monofold:init` | Create or update `.pi/monofold.yaml` |
 | `/monofold:update` | Migrate legacy config and optionally request config edits |
 
-Default focus shortcut: `ctrl+shift+m` cycles Active Focus forward through `focusPresets` YAML order. No backward focus shortcut ships in the MVP.
+Default focus shortcuts: `ctrl+shift+m` cycles Active Focus forward and `shift+ctrl+f` cycles backward through `focusPresets` YAML order. Both wrap at the start/end of the list.
 
 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:
 

package/focus-preset.ts

@@ -1,3 +1,4 @@
+import { type MonofoldRouteType, parseDefaultRouteOverride } from "./focus-route-override.js";
 import { parseFocusSkills, resetFocusSkillsWarningState } from "./focus-skills.js";
 import { assertKnownKeys, asStringArray, isRecord, uniqueStrings } from "./validation.js";
 
@@ -10,13 +11,14 @@ export type FocusPreset = {
   label: string;
   targets: FocusPresetTarget[];
   focusSkills?: string[];
+  defaultRouteOverride?: MonofoldRouteType;
 };
 
 export type FocusMatchableWorkspace = {
   tags: string[];
 };
 
-const FOCUS_PRESET_KEYS = new Set(["id", "label", "targets", "focusSkills"]);
+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. */
@@ -52,6 +54,7 @@ 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({
@@ -59,6 +62,7 @@ export function parseFocusPresets(value: unknown, label = "focusPresets"): Focus
       label: item.label,
       targets,
       ...(focusSkills !== undefined ? { focusSkills } : {}),
+      ...(defaultRouteOverride !== undefined ? { defaultRouteOverride } : {}),
     });
   }
   return presets;
@@ -182,6 +186,25 @@ export function cycleActiveFocusPresetForward(focusPresets: FocusPreset[] | unde
   return { preset, index: nextIndex, total: presets.length, changed };
 }
 
+/** Cycles the active focus preset backward in YAML order. */
+export function cycleActiveFocusPresetBackward(focusPresets: FocusPreset[] | undefined): FocusCycleResult | null {
+  const presets = focusPresets ?? [];
+  if (presets.length === 0) {
+    clearActiveFocusPresetId();
+    return null;
+  }
+
+  ensureActiveFocusInitialized(presets);
+  const currentId = getActiveFocusPresetId();
+  const currentIndex = currentId ? presets.findIndex((preset) => preset.id === currentId) : -1;
+  const nextIndex =
+    currentIndex < 0 ? presets.length - 1 : (currentIndex - 1 + presets.length) % presets.length;
+  const preset = presets[nextIndex]!;
+  const changed = presets.length > 1 && preset.id !== currentId;
+  setActiveFocusPresetId(preset.id, presets);
+  return { preset, index: nextIndex, total: presets.length, changed };
+}
+
 /** Clears the active focus preset for the current process/session. */
 export function clearActiveFocusPresetId(): void {
   activeFocusPresetId = null;

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/index.ts

@@ -6,6 +6,7 @@ import path from "node:path";
 import YAML from "yaml";
 import {
   type ActiveFocusPresetPosition,
+  cycleActiveFocusPresetBackward,
   cycleActiveFocusPresetForward,
   type FocusPreset,
   ensureActiveFocusInitialized,
@@ -20,6 +21,10 @@ import {
   setActiveFocusPresetId,
   warnZeroTargetMatchesForPreset,
 } from "./focus-preset.js";
+import {
+  resolveWriteRouteType,
+  type MonofoldRouteType,
+} from "./focus-route-override.js";
 import {
   applyFocusSkillsToSystemPrompt,
   warnMissingFocusSkills,
@@ -41,7 +46,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;
@@ -177,6 +182,8 @@ const ROUTE_KEYS = new Set(["path", "filenameTemplate", "metadata"]);
 const FOCUS_STATUS_ID = "monofold-focus";
 const FOCUS_CYCLE_SHORTCUT = "ctrl+shift+m";
 const FOCUS_CYCLE_ACTION_ID = "app.monofold.focus.cycleForward";
+const FOCUS_CYCLE_BACKWARD_SHORTCUT = "shift+ctrl+f";
+const FOCUS_CYCLE_BACKWARD_ACTION_ID = "app.monofold.focus.cycleBackward";
 export const FOCUS_CONTEXT_MAX_FILES = 6;
 export const FOCUS_CONTEXT_MAX_CHARS_PER_FILE = 6_000;
 export const FOCUS_CONTEXT_MAX_TOTAL_CHARS = 12_000;
@@ -892,7 +899,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} / ${FOCUS_CYCLE_BACKWARD_SHORTCUT}`;
+  if (position.preset.defaultRouteOverride) {
+    return `${base} route:${position.preset.defaultRouteOverride}`;
+  }
+  return base;
 }
 
 function updateFocusStatus(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig): void {
@@ -1026,6 +1037,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)"));
       }
@@ -1046,6 +1060,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;
@@ -1386,7 +1403,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()),
@@ -1397,9 +1414,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,
@@ -1613,14 +1630,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`);
@@ -1887,11 +1905,38 @@ ${focusInjection.text}` : ""}
     }
   };
 
+  const cycleFocusBackward = async (ctx: ExtensionContext) => {
+    try {
+      const loaded = await loadConfig(ctx.cwd);
+      const focusPresets = loaded.raw.focusPresets ?? [];
+      if (focusPresets.length === 0) {
+        notifyNoFocusPresets(ctx);
+        return;
+      }
+      const result = cycleActiveFocusPresetBackward(focusPresets);
+      if (!result) return;
+      updateFocusStatus(ctx, loaded);
+      warnZeroTargetMatchesForPreset(result.preset, loaded.workspaces, (message) => ctx.ui.notify(message, "warning"));
+      if (focusPresets.length === 1) {
+        ctx.ui.notify(`Active Focus unchanged: ${result.preset.label} (1/1)`, "info");
+        return;
+      }
+      ctx.ui.notify(`Active Focus: ${result.preset.label} (${result.index + 1}/${result.total})`, "info");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Monofold focus cycle failed: ${message}`, "error");
+    }
+  };
+
   pi.registerCommand("monofold:explore", { description: "Explore configured workspaces via natural-language handoff", handler: intentCommand("Explore") });
   pi.registerCommand("monofold:write", { description: "Create routed Markdown via natural-language handoff", handler: intentCommand("Write") });
   pi.registerCommand("monofold:config", { description: "Change Workspace configuration via natural-language handoff", handler: intentCommand("Config") });
   pi.registerCommand("monofold:git", { description: "Run workspace git workflows via natural-language handoff", handler: intentCommand("Git") });
   pi.registerCommand("monofold:focus", { description: "Select the active Monofold focus preset from a TUI list", handler: focusCommand });
+  pi.registerCommand("monofold:focus-prev", {
+    description: "Cycle the active Monofold focus preset backward through focusPresets YAML order",
+    handler: (_args, ctx) => cycleFocusBackward(ctx),
+  });
   pi.registerCommand("monofold:guide", { description: "Conversational guide for Pi Monofold workflows", handler: guideCommand });
   pi.registerCommand("monofold:update", { description: `Migrate and validate ${CONFIG_RELATIVE_PATH}`, handler: updateCommand });
   pi.registerCommand("monofold:clear-unknown-path-allows", {
@@ -1904,6 +1949,11 @@ ${focusInjection.text}` : ""}
     handler: cycleFocusForward,
   });
 
+  pi.registerShortcut(FOCUS_CYCLE_BACKWARD_SHORTCUT, {
+    description: `${FOCUS_CYCLE_BACKWARD_ACTION_ID}: cycle active Monofold focus preset backward`,
+    handler: cycleFocusBackward,
+  });
+
 
   pi.registerCommand("monofold:list", { description: "List configured Pi Monofold workspaces (legacy)", handler: listCommand });
 

package/package.json

@@ -1,64 +1,66 @@
-{
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test tests/**/*.test.ts",
-    "check": "npm run typecheck && npm test && npm pack --dry-run"
-  },
-  "peerDependencies": {
-    "typebox": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-ai": "*"
-  },
-  "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
-  "type": "module",
-  "version": "0.7.0",
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "files": [
-    "README.md",
-    "LICENSE",
-    "index.ts",
-    "path-normalize.ts",
-    "unknown-path-allows.ts",
-    "file-read-preview.ts",
-    "focus-preset.ts",
-    "focus-skills.ts",
-    "monofold-read-ops.ts",
-    "read-caps.ts",
-    "validation.ts"
-  ],
-  "name": "pi-monofold",
-  "devDependencies": {
-    "typescript": "^6.0.3",
-    "typebox": "^1.1.38",
-    "@types/node": "^25.9.1",
-    "tsx": "^4.20.5",
-    "@earendil-works/pi-coding-agent": "^0.75.4",
-    "@earendil-works/pi-ai": "^0.75.4"
-  },
-  "dependencies": {
-    "yaml": "^2.8.1"
-  },
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "ai-coding",
-    "virtual-monorepo",
-    "multi-repo"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/eiei114/pi-monofold.git"
-  },
-  "bugs": {
-    "url": "https://github.com/eiei114/pi-monofold/issues"
-  },
-  "homepage": "https://github.com/eiei114/pi-monofold#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT"
-}
+{
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/**/*.test.ts",
+    "check": "npm run typecheck && npm test && npm pack --dry-run",
+    "version:check": "node scripts/check-version-bump.mjs"
+  },
+  "peerDependencies": {
+    "typebox": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*"
+  },
+  "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
+  "type": "module",
+  "version": "0.9.0",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "index.ts",
+    "path-normalize.ts",
+    "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"
+  ],
+  "name": "pi-monofold",
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "typebox": "^1.1.38",
+    "@types/node": "^25.9.1",
+    "tsx": "^4.20.5",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4"
+  },
+  "dependencies": {
+    "yaml": "^2.8.1"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "ai-coding",
+    "virtual-monorepo",
+    "multi-repo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eiei114/pi-monofold.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eiei114/pi-monofold/issues"
+  },
+  "homepage": "https://github.com/eiei114/pi-monofold#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}