Pi Windows 工作流第三版：继续迭代

{

  "tui.editor.cursorUp": ["up", "ctrl+p", "alt+k"],

  "tui.editor.cursorDown": ["down", "ctrl+n", "alt+j"],

  "tui.editor.cursorLeft": ["left", "ctrl+b", "alt+h"],

  "tui.editor.cursorRight": ["right", "ctrl+f", "alt+l"],

  "tui.editor.cursorWordLeft": ["alt+left", "alt+b"],

  "tui.editor.cursorWordRight": ["alt+right", "alt+f", "alt+w"],

  "tui.editor.deleteCharForward": ["delete", "ctrl+d"],

  "tui.editor.deleteCharBackward": ["backspace", "ctrl+h"],

  "tui.editor.deleteWordBackward": ["ctrl+w", "alt+backspace"],

  "tui.input.newLine": ["shift+enter", "ctrl+j", "alt+enter"]

}

{

  "timeout": 30000,

  "servers": {

    "ruff": {

      "command": ["ruff", "server"],

      "extensions": [".py", ".pyi"],

      "skipDirectories": [

        ".git",

        ".mypy_cache",

        ".pytest_cache",

        ".ruff_cache",

        ".venv",

        "__pycache__",

        "node_modules"

      ]

    }

  }

}

{

  "thinkingLevel": "inherit",

  "defaultPlanTools": [

    "read",

    "bash",

    "grep",

    "find",

    "ls",

    "subagent"

  ],

  "implementationPlanRetention": "clear-after-first-run",

  "defaultPlanExportPath": "PLAN.md",

  "safeSubcommands": {

    "git": [

      "status",

      "log",

      "diff",

      "show",

      "branch",

      "remote",

      "ls-files",

      "grep",

      "rev-parse",

      "blame",

      "describe",

      "merge-base",

      "ls-tree",

      "cat-file"

    ]

  }

}

{

  "toolDescriptionMode": "compact",

  "asyncByDefault": true,

  "inlineToolDisplay": "summary",

  "waitTool": {

    "enabled": true

  },

  "forceTopLevelAsync": false,

  "globalConcurrencyLimit": 6,

  "parallel": {

    "maxTasks": 6,

    "concurrency": 6

  },

  "maxSubagentSpawnsPerSession": 24,

  "maxSubagentDepth": 1,

  "completionBatch": {

    "enabled": true,

    "debounceMs": 150,

    "maxWaitMs": 1000,

    "stragglerDebounceMs": 75,

    "stragglerMaxWaitMs": 400,

    "stragglerWindowMs": 2000

  },

  "worktreeBaseDir": "<ABSOLUTE_WINDOWS_WORKTREE_DIR>"

}

---

name: <plan-scout|plan-researcher|plan-reviewer>

description: Read-only investigation or review for a planning session.

tools: read, grep, find, ls

extensions:

model: <openai/gpt-5.6-luna|openai/gpt-5.6-terra>

thinking: <low|medium>

systemPromptMode: replace

inheritProjectContext: true

inheritSkills: false

defaultContext: fresh

acceptanceRole: read-only

permission:

  "*": deny

  read: allow

  grep: allow

  find: allow

  ls: allow

  edit: deny

  write: deny

  mcp: deny

  skill: deny

  external_directory: deny

  special: deny

---

import { createRequire } from "node:module";

import { join } from "node:path";

import { pathToFileURL } from "node:url";

import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";



const PLAN_TOOLS = new Set(["plan_mode_question", "plan_mode_complete"]);

const ALLOWED_AGENTS = ["plan-scout", "plan-researcher", "plan-reviewer"];

const ALLOWED_TOOLS = ["read", "grep", "find", "ls"];



type CeilingHandle = { dispose(): void };

type RegisterCapabilityCeiling = (options: {

	sessionId: string;

	source: string;

	ceiling: {

		allowedAgents: string[];

		allowedTools: string[];

		denyExtensions: boolean;

	};

}) => CeilingHandle;



type CapabilityCeilingModule = {

	registerSubagentCapabilityCeiling?: RegisterCapabilityCeiling;

};



type JitiLoader = {

	import(specifier: string): Promise<unknown>;

};



let subagentPackageLoader: JitiLoader | undefined;



async function loadCapabilityCeilingModule(): Promise<CapabilityCeilingModule> {

	if (!subagentPackageLoader) {

		const agentDir = getAgentDir();

		const requireFromAgentPackages = createRequire(join(agentDir, "npm", "package.json"));

		const { createJiti } = requireFromAgentPackages("jiti") as {

			createJiti?: (id: string, options?: { moduleCache?: boolean }) => JitiLoader;

		};

		if (typeof createJiti !== "function") {

			throw new Error("Pi user package loader is unavailable");

		}

		subagentPackageLoader = createJiti(

			pathToFileURL(join(agentDir, "npm", "package.json")).href,

			{ moduleCache: false },

		);

	}

	return (await subagentPackageLoader.import("pi-subagents/capability-ceiling")) as CapabilityCeilingModule;

}



export default function planSubagentCeiling(pi: ExtensionAPI) {

	let handle: CeilingHandle | undefined;

	let sessionId: string | undefined;

	let syncPromise: Promise<boolean> | undefined;



	const isPlanActive = () => {

		try {

			return pi.getActiveTools().some((tool) => PLAN_TOOLS.has(tool));

		} catch {

			return false;

		}

	};



	const clear = () => {

		handle?.dispose();

		handle = undefined;

		sessionId = undefined;

	};



	const sync = (ctx: ExtensionContext): Promise<boolean> => {

		if (syncPromise) return syncPromise;

		const current = (async () => {

			if (!isPlanActive()) {

				clear();

				return true;

			}



			const currentSessionId = ctx.sessionManager.getSessionId();

			if (!currentSessionId) return false;

			if (handle && sessionId === currentSessionId) return true;



			clear();

			try {

				const module = await loadCapabilityCeilingModule();

				if (typeof module.registerSubagentCapabilityCeiling !== "function") return false;

				handle = module.registerSubagentCapabilityCeiling({

					sessionId: currentSessionId,

					source: "local-plan-subagent-ceiling",

					ceiling: {

						allowedAgents: ALLOWED_AGENTS,

						allowedTools: ALLOWED_TOOLS,

						denyExtensions: true,

					},

				});

				sessionId = currentSessionId;

				return true;

			} catch {

				clear();

				return false;

			}

		})();

		syncPromise = current;

		return current.finally(() => {

			if (syncPromise === current) syncPromise = undefined;

		});

	};



	pi.on("session_start", async (_event, ctx) => {

		await sync(ctx);

	});



	pi.on("before_agent_start", async (_event, ctx) => {

		await sync(ctx);

	});



	pi.on("tool_call", async (event, ctx) => {

		if (event.toolName !== "subagent") return;

		if (!isPlanActive()) {

			await sync(ctx);

			return;

		}

		if (await sync(ctx)) return;

		return {

			block: true,

			reason:

				"Plan-mode subagent delegation is blocked because the local capability-ceiling bridge could not load pi-subagents/capability-ceiling.",

		};

	});



	pi.on("session_shutdown", () => {

		clear();

	});

}

{

  "permission": {

    "*": "allow",

    "read": "allow",

    "grep": "allow",

    "find": "allow",

    "ls": "allow",

    "external_directory": { "*": "ask", "~/.pi/agent/*": "allow" },

    "path": {

      "*": "allow",

      "*.env": "deny",

      "~/.ssh/*": "deny",

      "~/.pi/agent/auth.json": "deny"

    },

    "bash": {

      "*": "allow",

      "Remove-Item *": "ask",

      "Set-Content *": "ask",

      "git diff *": "allow",

      "git log *": "allow",

      "git show *": "allow",

      "git rev-parse *": "allow"

    }

  }

}

{

  "enabled": true,

  "registerToolOverrides": {

    "read": false,

    "grep": true,

    "find": true,

    "ls": true,

    "bash": false,

    "edit": false,

    "write": false

  },

  "readOutputMode": "summary",

  "searchOutputMode": "count",

  "mcpOutputMode": "summary",

  "bashOutputMode": "opencode",

  "diffViewMode": "auto",

  "diffWordWrap": true

}

{

  "settings": {

    "directTools": false

  },

  "mcpServers": {

    "sequential-thinking": {

      "command": "cmd",

      "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],

      "lifecycle": "eager",

      "directTools": true

    },

    "context7-1": {

      "url": "<CONTEXT7_MCP_URL>",

      "protocolVersion": "auto",

      "lifecycle": "eager",

      "directTools": true

    },

    "playwright": {

      "command": "cmd",

      "args": ["/c", "npx", "-y", "@playwright/mcp@latest"],

      "lifecycle": "lazy"

    },

    "mcp-server-time": {

      "command": "uvx",

      "args": ["--with", "mcp>=1.23,<2", "mcp-server-time", "--local-timezone=Asia/Shanghai"],

      "lifecycle": "eager",

      "directTools": true

    },

    "shrimp-task-manager": {

      "command": "cmd",

      "args": ["/c", "npx", "-y", "mcp-shrimp-task-manager"],

      "lifecycle": "eager",

      "directTools": true,

      "env": {

        "DATA_DIR": "<MCP_DATA_DIR>",

        "ENABLE_GUI": "false",

        "TEMPLATES_USE": "en"

      }

    },

    "mcp-deepwiki": {

      "url": "<DEEPWIKI_MCP_URL>",

      "protocolVersion": "auto",

      "lifecycle": "eager",

      "directTools": true

    },

    "chrome-devtools-mcp": {

      "command": "cmd",

      "args": ["/c", "npx", "-y", "chrome-devtools-mcp@latest"],

      "lifecycle": "lazy"

    }

  }

}